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

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

@@ -0,0 +1,144 @@
+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,
+    epoch_ms_to_date,
+    geocode,
+    query_feature_layer,
+)
+
+TITLE = "Alexandria, VA"
+DESCRIPTION = "Source for City of Alexandria, VA trash, recycling and leaf collection."
+URL = "https://www.alexandriava.gov/RefuseCollection"
+COUNTRY = "us"
+
+TEST_CASES = {
+    "City Hall, 301 King St": {"address": "301 King St, Alexandria, VA 22314"},
+}
+
+SOURCE_CODEOWNERS = ["@lpukatch"]
+
+ICON_MAP = {
+    "Trash": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Leaf Collection": Icons.ORGANIC,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Full street address including city and state (e.g. '301 King St, Alexandria, VA 22314')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+# City of Alexandria alx311Info MapServer.
+# Layer 3 = Refuse Day Zone (field DAYSERVED), layer 2 = Recycle Zones (field PICKUPDAY),
+# layer 16 = Leaf Zones (field PassDate, one feature per seasonal collection pass).
+MAPSERVER = "https://maps.alexandriava.gov/alexmaps/rest/services/alx311Info/MapServer"
+REFUSE_URL = f"{MAPSERVER}/3"
+RECYCLE_URL = f"{MAPSERVER}/2"
+LEAF_URL = f"{MAPSERVER}/16"
+
+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] = []
+
+        # Trash / refuse — every eligible address falls in a refuse day zone.
+        refuse_day = self._query_day(location, REFUSE_URL, "DAYSERVED")
+        if refuse_day is None:
+            # No refuse zone means the address could not be matched at all.
+            raise SourceArgumentNotFound("address", self._address)
+        entries += self._weekly_dates(refuse_day, "Trash")
+
+        # Recycling — not every address is eligible for city recycling
+        # (e.g. commercial buildings return PICKUPDAY "None"); skip if absent.
+        recycle_day = self._query_day(location, RECYCLE_URL, "PICKUPDAY")
+        if recycle_day is not None:
+            entries += self._weekly_dates(recycle_day, "Recycling")
+
+        # Leaf collection — seasonal vacuum-leaf passes with explicit dates.
+        # The layer only holds the current season, so this yields nothing
+        # outside the fall/winter leaf-collection period.
+        entries += self._leaf_dates(location)
+
+        return entries
+
+    @staticmethod
+    def _query_day(location: dict[str, float], url: str, field: str) -> str | None:
+        try:
+            features = query_feature_layer(url, geometry=location, out_fields=field)
+        except ArcGisError:
+            return None
+
+        value = (features[0].get(field) or "").strip().title()
+        if value not in WEEKDAYS:
+            return None
+        return value
+
+    @staticmethod
+    def _leaf_dates(location: dict[str, float]) -> list[Collection]:
+        try:
+            features = query_feature_layer(
+                LEAF_URL, geometry=location, out_fields="PassDate"
+            )
+        except ArcGisError:
+            return []
+
+        icon = ICON_MAP.get("Leaf Collection")
+        entries: list[Collection] = []
+        for attrs in features:
+            pass_date = attrs.get("PassDate")
+            if not pass_date:
+                continue
+            entries.append(
+                Collection(
+                    date=epoch_ms_to_date(pass_date),
+                    t="Leaf Collection",
+                    icon=icon,
+                )
+            )
+        return entries
+
+    @staticmethod
+    def _weekly_dates(day_name: str, waste_type: str) -> list[Collection]:
+        weekday = WEEKDAYS[day_name]
+        today = date.today()
+        days_ahead = (weekday - today.weekday()) % 7
+        next_date = today + timedelta(days=days_ahead)
+        icon = ICON_MAP.get(waste_type)
+        return [
+            Collection(
+                date=next_date + timedelta(weeks=i),
+                t=waste_type,
+                icon=icon,
+            )
+            for i in range(WEEKS_AHEAD)
+        ]

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

@@ -0,0 +1,220 @@
+import json
+
+import requests
+from waste_collection_schedule.service.junker_app import Junker
+
+TITLE = "Alia Servizi Ambientali S.p.A."
+DESCRIPTION = "Source for Alia Servizi Ambientali S.p.A.."
+URL = "https://www.aliaserviziambientali.it"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit <https://www.aliaserviziambientali.it/it-it/raccolta-rifiuti> and select your municiaplity, if you see an embedded calendar you can just use the municipality name, and leave the area empty. If you see a list of areas, you need to follow the link to the area calendar, there you can fin the area ID in the URL, for example: `https://differenziata.junker.app/embed/barberino-tavarnelle/area/67333/calendario` the area ID is `67333`.",
+    "it": "Visita https://www.aliaserviziambientali.it/it-it/raccolta-rifiuti e seleziona il tuo comune. Se vedi un calendario incorporato, puoi semplicemente utilizzare il nome del comune e lasciare vuoto il campo dell'area. Se invece vedi un elenco di aree, devi seguire il link al calendario dell'area; lì puoi trovare l'ID dell'area nell'URL, ad esempio: https://differenziata.junker.app/embed/barberino-tavarnelle/area/67333/calendario l'ID dell'area è 67333.",
+}
+
+TEST_CASES = {
+    "Gambassi Terme": {"municipality": "Gambassi Terme"},
+    "Barberino Tavarnelle Loc. San Donato": {
+        "municipality": "Barberino Tavarnelle",
+        "area": 67334,
+    },
+    "Arrighi, Castello, Lecore, San Mauro (centro storico), San Rocco, San Piero a Ponti e Sant'Angelo a Lecore": {
+        "municipality": "Signa",
+        "area": 11970,
+    },
+}
+
+
+API_URL = "https://differenziata.junker.app/embed/{municipality}/calendario"
+API_URL_WITH_AREA = (
+    "https://differenziata.junker.app/embed/{municipality}/area/{area}/calendario"
+)
+
+MUNICIPALITIES_WITH_AREA = {
+    "Bagno a Ripoli": [12035, 12036],
+    "Barberino Tavarnelle": [67333, 67334],
+    "Calenzano": [11887, 11886],
+    "Carmignano": [11888, 11889],
+    "Empoli": [11890, 11926, 11891],
+    "Fiesole": [11905, 11906, 11907, 11908],
+    "Figline e Incisa Valdarno": [11904, 11903],
+    "Firenze": [12089, 12082],
+    "Greve in Chianti": [12048, 12049, 12046, 12047],
+    "Impruneta": [12054, 12068, 12053, 12055],
+    "Marliana": [13016],
+    "Montecatini Terme": [12037, 12038],
+    "Pescia": [11959, 11963, 11960, 11964, 11961, 11965],
+    "Pistoia": [
+        12101,
+        12729,
+        12728,
+        12103,
+        12730,
+        12731,
+        13004,
+        13005,
+        12951,
+        12954,
+        12952,
+        12953,
+    ],
+    "Poggio a Caiano": [11898, 11899],
+    "Prato": [
+        12007,
+        12008,
+        12009,
+        12010,
+        12011,
+        12012,
+        12013,
+        12014,
+        67812,
+        12016,
+        12030,
+        12031,
+        12032,
+        12033,
+        12034,
+        12015,
+        12025,
+        12026,
+        12027,
+        12028,
+        12029,
+        12017,
+        12018,
+        12019,
+        12020,
+        12022,
+        12021,
+        12021,
+        68415,
+        12023,
+        12024,
+    ],
+    "Sambuca Pistoiese": [13018, 13019],
+    "San Casciano in Val di Pesa": [12057, 12058],
+    "San Marcello Piteglio": [13020, 13021],
+    "Scandicci": [
+        11909,
+        11911,
+        11912,
+        11913,
+        11914,
+        11915,
+        11916,
+        11917,
+        11918,
+        11919,
+        11920,
+        11921,
+        11922,
+    ],
+    "Sesto Fiorentino": [11972, 11973],
+    "Signa": [11970, 11969, 11971],
+    "Vaiano": [11893, 11894],
+}
+
+MUNICIPALITIES_WITHOUT_AREA = [
+    "Agliana",
+    "Barberino di Mugello",
+    "Borgo San Lorenzo",
+    "Buggiano",
+    "Campi Bisenzio",
+    "Cantagallo",
+    "Capraia e Limite",
+    "Castelfiorentino",
+    "Cerreto Guidi",
+    "Certaldo",
+    "Chiesina Uzzanese",
+    "Fucecchio",
+    "Gambassi Terme",
+    "Lamporecchio",
+    "Larciano",
+    "Lastra a Signa",
+    "Massa e Cozzile",
+    "Monsummano Terme",
+    "Montaione",
+    "Montale",
+    "Montelupo Fiorentino",
+    "Montemurlo",
+    "Montespertoli",
+    "Pieve a Nievole",
+    "Ponte Buggianese",
+    "Quarrata",
+    "Rignano sull'Arno",
+    "Scarperia e San Piero",
+    "Serravalle Pistoiese",
+    "Uzzano",
+    "Vaglia",
+    "Vernio",
+    "Vicchio",
+    "Vinci",
+]
+
+MUNICIPALITIES = list(MUNICIPALITIES_WITH_AREA.keys()) + MUNICIPALITIES_WITHOUT_AREA
+EXTRA_INFO = [
+    {"title": mun, "default_params": {"municipality": mun}} for mun in MUNICIPALITIES
+]
+
+
+class Source(Junker):
+    def __init__(self, municipality: str, area: int | None = None):
+        super().__init__(
+            municipality,
+            area,
+            use_embed_url=True,
+            municipalities_with_area=MUNICIPALITIES_WITH_AREA,
+        )
+
+
+def print_municipalities() -> None:
+    from bs4 import BeautifulSoup
+
+    r = requests.get("https://www.aliaserviziambientali.it/it-it/raccolta-rifiuti")
+    r.raise_for_status()
+    soup = BeautifulSoup(r.text, "html.parser")
+    mun_options = soup.select_one("script#comuni")
+    if not mun_options:
+        raise ValueError("No municipalities found")
+    muns = json.loads(mun_options.text)
+
+    municipalites_without_area: list[str] = []
+    municipalities_with_area: dict[str, list[int]] = {}
+
+    for mun in muns:
+        mun_name: str = mun["comune"]
+        mun_url: str = mun["url"]
+        if mun_url.startswith("/"):
+            mun_url = "https://www.aliaserviziambientali.it" + mun_url
+
+        r = requests.get(mun_url)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+        iframe = soup.select_one("iframe")
+        if iframe:
+            iframe_url = iframe["src"]
+            if "area" in iframe_url:
+                area = int(iframe_url.split("/")[-2])
+                municipalities_with_area[mun_name] = [area]
+            else:
+                municipalites_without_area.append(mun_name)
+
+        junker_links = soup.select("a[href*='differenziata.junker.app']")
+
+        for link in junker_links:
+            if "area" in link["href"]:
+                area = int(link["href"].split("/")[-2])
+                municipalities_with_area[mun_name] = [
+                    *municipalities_with_area.get(mun_name, []),
+                    area,
+                ]
+            else:
+                municipalites_without_area.append(mun_name)
+
+    print(f"MUNICIPALITIES_WITH_AREA = {municipalities_with_area}")
+    print(f"MUNICIPALITIES_WITHOUT_AREA = {municipalites_without_area}")
+
+
+if __name__ == "__main__":
+    print_municipalities()

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

@@ -0,0 +1,59 @@
+from datetime import datetime
+
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.WhitespaceWRP import WhitespaceClient
+
+TITLE = "Allerdale Borough Council"
+DESCRIPTION = "Source for www.allerdale.gov.uk services for Allerdale Borough Council."
+URL = "https://www.allerdale.gov.uk"
+TEST_CASES = {
+    "Keswick": {
+        "address_postcode": "CA12 4HU",
+        "address_name_number": "11",
+    },
+    "Workington": {
+        "address_postcode": "CA14 3NS",
+        "address_name_number": "177",
+    },
+    "Wigton": {
+        "address_postcode": "CA7 9RS",
+        "address_name_number": "55",
+    },
+}
+ICON_MAP = {
+    "Domestic Waste": Icons.GENERAL_WASTE,
+    "Glass Cans and Plastic Recycling": Icons.PLASTIC_PACKAGING,
+    "Garden Waste": Icons.GARDEN,
+}
+API_URL = "https://abc-wrp.whitespacews.com/"
+
+
+class Source:
+    def __init__(
+        self,
+        address_name_number=None,
+        address_postcode=None,
+    ):
+        self._address_name_number = address_name_number
+        self._address_postcode = address_postcode
+        self._client = WhitespaceClient(API_URL)
+
+    def fetch(self):
+        schedule = self._client.fetch_schedule(
+            address_name_number=self._address_name_number,
+            address_postcode=self._address_postcode,
+        )
+
+        entries = []
+        for date_str, type_str in schedule:
+            collection_type = type_str.replace(" Collection", "").replace(
+                " Service", ""
+            )
+            entries.append(
+                Collection(
+                    date=datetime.strptime(date_str, "%d/%m/%Y").date(),
+                    t=type_str,
+                    icon=ICON_MAP.get(collection_type),
+                )
+            )
+        return entries

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

@@ -0,0 +1,144 @@
+import re
+from datetime import date
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+)
+
+TITLE = "Älvsbyns Energi"
+DESCRIPTION = "Waste collection schedule for Älvsbyns Energi, Sweden."
+URL = "https://www.alvsbynsenergi.se/"
+COUNTRY = "se"
+
+TEST_CASES = {
+    "Storgatan 24": {
+        "address": "Storgatan 24",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Address",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address and house number.",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter the street address and house number as shown by the address "
+    "search at https://www.alvsbynsenergi.se/ (for example, Storgatan 24).",
+}
+
+ICON_MAP = {
+    "Matavfall": Icons.BIO_KITCHEN,
+    "Restavfall": Icons.GENERAL_WASTE,
+}
+
+BASE_URL = "https://www.alvsbynsenergi.se"
+ADDRESS_URL = f"{BASE_URL}/assets/data/ajax.fetch_address.php"
+SCHEDULE_URL = f"{BASE_URL}/renhallning/sophamtning/{{street_id}}-{{area_code}}"
+DATE_PATTERN = re.compile(r"^(\d{4}-\d{2}-\d{2})")
+
+
+def _normalise(value: str) -> str:
+    return " ".join(value.split()).casefold()
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = (address or "").strip()
+        if not self._address:
+            raise SourceArgumentRequired(
+                "address",
+                "A street address and house number are required.",
+            )
+
+    def fetch(self) -> list[Collection]:
+        response = requests.get(
+            ADDRESS_URL,
+            params={"query": self._address},
+            timeout=30,
+        )
+        response.raise_for_status()
+
+        suggestions = response.json().get("suggestions", [])
+        normalised_address = _normalise(self._address)
+        matches = [
+            suggestion
+            for suggestion in suggestions
+            if _normalise(suggestion.get("value", "")).startswith(normalised_address)
+        ]
+
+        if len(matches) != 1:
+            suggestion_values = sorted(
+                suggestion.get("value", "").strip()
+                for suggestion in suggestions
+                if suggestion.get("value", "").strip()
+            )
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address",
+                self._address,
+                suggestion_values,
+            )
+
+        street_id = matches[0].get("street_id")
+        area_code = matches[0].get("area_code")
+        if not street_id or not area_code:
+            raise ValueError("Unexpected address response from Älvsbyns Energi.")
+
+        response = requests.get(
+            SCHEDULE_URL.format(
+                street_id=street_id,
+                area_code=area_code,
+            ),
+            timeout=30,
+        )
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, "html.parser")
+        details = soup.select_one("#waste-empty-details")
+        if details is None:
+            raise ValueError(
+                "Collection schedule was not found in the Älvsbyns Energi response."
+            )
+
+        entries = []
+        for item in details.find_all("span", recursive=False):
+            text = item.get_text(" ", strip=True)
+            match = DATE_PATTERN.match(text)
+            if match is None:
+                continue
+
+            collection_date = date.fromisoformat(match.group(1))
+
+            entries.append(
+                Collection(
+                    date=collection_date,
+                    t="Matavfall",
+                    icon=ICON_MAP["Matavfall"],
+                )
+            )
+
+            if "matavfall" not in text.casefold():
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t="Restavfall",
+                        icon=ICON_MAP["Restavfall"],
+                    )
+                )
+
+        if not entries:
+            raise ValueError(
+                "No collection dates were found in the Älvsbyns Energi response."
+            )
+
+        return entries