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

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

@@ -0,0 +1,65 @@
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.SiteparkIES import SiteparkIES, match_icon
+
+TITLE = "Kreiswirtschaftsbetriebe Goslar"
+DESCRIPTION = "Source for kwb-goslar.de waste collection."
+URL = "https://www.kwb-goslar.de"
+COUNTRY = "de"
+TEST_CASES = {
+    "Berliner Straße (Clausthal-Zellerfeld)": {"pois": "2523.602"},
+    "Braunschweiger Straße (Seesen)": {"pois": "2523.409"},
+    "Marktstraße (Seesen)": {"strasse": "Marktstraße", "ort": "Seesen"},
+}
+
+ICON_MAP = {
+    "Baum- und Strauchschnitt": Icons.ORGANIC,
+    "Biotonne": Icons.BIO_KITCHEN,
+    "Blaue Tonne": Icons.NEWSPAPER,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Restmülltonne": Icons.GENERAL_WASTE,
+    "Weihnachtsbäume": Icons.CHRISTMAS_TREE,
+}
+
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "strasse": "Straße",
+        "ort": "Ort",
+        "pois": "POIS",
+    },
+    "en": {
+        "strasse": "Street",
+        "ort": "Place",
+        "pois": "POIS",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "de": {
+        "strasse": "Straßenname (per Autocomplete aufgelöst).",
+        "ort": "Optionaler Ort/Ortsteil zur Eindeutigkeit (z.B. 'Seesen').",
+        "pois": "Direkte POIS-ID (Alternative zur Straßeneingabe).",
+    },
+    "en": {
+        "strasse": "Street name (resolved via autocomplete).",
+        "ort": "Optional place/district to disambiguate (e.g. 'Seesen').",
+        "pois": "Direct POIS id (alternative to entering a street).",
+    },
+}
+
+
+class Source:
+    def __init__(self, strasse=None, ort=None, pois=None):
+        self._strasse = strasse
+        self._ort = ort
+        self._pois = pois
+        self._sitepark = SiteparkIES(URL)
+
+    def fetch(self):
+        dates = self._sitepark.fetch(
+            strasse=self._strasse, ort=self._ort, pois=self._pois
+        )
+        return [
+            Collection(date=date, t=waste_type, icon=match_icon(waste_type, ICON_MAP))
+            for date, waste_type in dates
+        ]

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

@@ -0,0 +1,153 @@
+import re
+from datetime import datetime, timedelta
+
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.IntraMaps import (
+    IntraMapsSearchError,
+    MapsClient,
+    MapsClientConfig,
+)
+
+TITLE = "City of Kwinana"
+DESCRIPTION = "Source for City of Kwinana waste collection."
+URL = "https://www.kwinana.wa.gov.au"
+COUNTRY = "au"
+
+TEST_CASES = {
+    "Kwinana Town Centre": {"address": "1 Chisham Avenue KWINANA TOWN CENTRE"},
+    "Wellard": {"address": "25 Breccia Parade WELLARD"},
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Garden Organics": Icons.GARDEN,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your street address including suburb "
+    "(e.g. '25 Breccia Parade WELLARD'). "
+    "Search at https://www.kwinana.wa.gov.au/property-and-pets/waste-and-recycling/your-bins-and-collection-day",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address with suburb (e.g. '25 Breccia Parade WELLARD')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+INTRAMAPS_CONFIG = MapsClientConfig(
+    base_url="https://kwinana.spatial.t1cloud.com",
+    instance="spatial/intramaps",
+    config_id="361cf79c-756a-4c28-903a-a8ed0347cacb",
+    project="139a0e2d-fa83-4232-86e9-5e29f342e289",
+    lite_config_id="96651193-ca0f-4797-95d7-98e972248fad",
+    module_id="cbd33a46-14e5-4ca2-9009-03a51dcbc889",
+    selection_layer_filter="c6352192-20e8-402c-85c1-ca8515d3cae3",
+    default_selection_layer="c6352192-20e8-402c-85c1-ca8515d3cae3",
+)
+
+WEEKDAYS = {
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+    "saturday": 5,
+    "sunday": 6,
+}
+
+# Map IntraMaps column names to waste types
+COLUMN_MAP = {
+    "Rubbish_Collection_Day": "General Waste",
+    "Recycle_Collection": "Recycling",
+    "Garden Organics Collection": "Garden Organics",
+}
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        try:
+            with MapsClient(INTRAMAPS_CONFIG) as client:
+                result = client.select_address(self._address)
+        except IntraMapsSearchError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        response = result["response"]
+        if not isinstance(response, dict):
+            raise SourceArgumentNotFound("address", self._address)
+
+        # Parse fields using column names (some fields have empty name/caption)
+        raw_fields = (
+            response.get("infoPanels", {})
+            .get("info1", {})
+            .get("feature", {})
+            .get("fields", [])
+        )
+
+        entries: list[Collection] = []
+        for field in raw_fields:
+            value = field.get("value", {})
+            if not isinstance(value, dict):
+                continue
+            column = value.get("column", "")
+            text = value.get("value", "")
+            waste_type = COLUMN_MAP.get(column)
+            if waste_type and text:
+                entries.extend(self._parse_schedule(text, waste_type))
+
+        return entries
+
+    @staticmethod
+    def _parse_schedule(text: str, waste_type: str) -> list[Collection]:
+        """Parse schedule text like 'Every Friday', 'Friday This Week', 'Friday Next Week'."""
+        icon = ICON_MAP.get(waste_type)
+        text_lower = text.strip().lower()
+
+        # "Every [Day]" — weekly
+        match = re.match(r"every\s+(\w+)", text_lower)
+        if match:
+            weekday = WEEKDAYS.get(match.group(1))
+            if weekday is not None:
+                today = datetime.now().date()
+                days_ahead = (weekday - today.weekday()) % 7
+                next_date = today + timedelta(days=days_ahead)
+                return [
+                    Collection(
+                        date=next_date + timedelta(weeks=i),
+                        t=waste_type,
+                        icon=icon,
+                    )
+                    for i in range(26)
+                ]
+
+        # "[Day] This Week" or "[Day] Next Week" — fortnightly
+        match = re.match(r"(\w+)\s+(this|next)\s+week", text_lower)
+        if match:
+            weekday = WEEKDAYS.get(match.group(1))
+            if weekday is not None:
+                today = datetime.now().date()
+                current_week_start = today - timedelta(days=today.weekday())
+                next_date = current_week_start + timedelta(days=weekday)
+                if match.group(2) == "next":
+                    next_date += timedelta(days=7)
+                return [
+                    Collection(
+                        date=next_date + timedelta(weeks=i * 2),
+                        t=waste_type,
+                        icon=icon,
+                    )
+                    for i in range(13)
+                ]
+
+        return []

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

@@ -0,0 +1,155 @@
+from datetime import date
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "KWU Entsorgung Landkreis Oder-Spree"
+DESCRIPTION = "Source for KWU Entsorgung, Germany"
+URL = "https://www.kwu-entsorgung.de/"
+TEST_CASES = {
+    "Erkner": {"city": "Erkner", "street": "Heinrich-Heine-Straße", "number": "11"},
+    "Bad Saarow": {"city": "Bad Saarow", "street": "Ahornallee", "number": 1},
+    "Spreenhagen Feldweg 4": {"city": "Spreenhagen", "street": "Feldweg", "number": 4},
+}
+
+HEADERS = {"user-agent": "Mozilla/5.0 (xxxx Windows NT 10.0; Win64; x64)"}
+ICON_MAP = {
+    "Restabfall": Icons.GENERAL_WASTE,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Papiertonne": Icons.PAPER,
+    "Biotonne": Icons.BIO_KITCHEN,
+}
+
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "city": "Ort",
+        "street": "Straße",
+        "number": "Hausnummer",
+    }
+}
+
+
+class Source:
+    def __init__(self, city, street, number):
+        self._city = city.strip().lower()
+        self._street = street.strip().lower()
+        self._number = str(number).lower().strip()
+        self._ics = ICS()
+
+    def fetch(self):
+        session = requests.Session()
+
+        r = requests.get(
+            "https://kalender.kwu-entsorgung.de", headers=HEADERS, verify=True
+        )
+
+        parsed_html = BeautifulSoup(r.text, "html.parser")
+        Orte = parsed_html.find_all("option")
+
+        OrtValue = None
+        for Ort in Orte:
+            if self._city == Ort.text.strip().lower():
+                OrtValue = Ort["value"]
+                break
+        if OrtValue is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "city", self._city, [o.text.strip() for o in Orte]
+            )
+
+        r = requests.get(
+            "https://kalender.kwu-entsorgung.de/kal_str2ort.php",
+            params={"ort": OrtValue},
+            headers=HEADERS,
+            verify=True,
+        )
+
+        parsed_html = BeautifulSoup(r.text, "html.parser")
+        Strassen = parsed_html.find_all("option")
+
+        StrasseValue = None
+        for Strasse in Strassen:
+            if self._street == Strasse.text.strip().lower():
+                StrasseValue = Strasse["value"]
+                break
+        if StrasseValue is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street", self._street, [s.text.strip() for s in Strassen]
+            )
+
+        r = requests.get(
+            "https://kalender.kwu-entsorgung.de/kal_str2ort.php",
+            params={"ort": OrtValue, "strasse": StrasseValue},
+            headers=HEADERS,
+            verify=True,
+        )
+
+        parsed_html = BeautifulSoup(r.text, "html.parser")
+        objects = parsed_html.find_all("option")
+
+        ObjektValue = None
+        for obj in objects:
+            if self._number == obj.text.lower().strip():
+                ObjektValue = obj["value"]
+                break
+        if ObjektValue is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "number", self._number, [o.text.strip() for o in objects]
+            )
+
+        r = requests.post(
+            "https://kalender.kwu-entsorgung.de/kal_uebersicht-2023.php",
+            data={
+                "ort": OrtValue,
+                "strasse": StrasseValue,
+                "objekt": ObjektValue,
+                "jahr": date.today().year,
+            },
+            headers=HEADERS,
+            verify=True,
+        )
+
+        parsed_html = BeautifulSoup(r.text, "html.parser")
+        Links = parsed_html.find_all("a")
+
+        for Link in Links:
+            if "ICal herunterladen" in Link.text:
+                ics_url = Link["href"]
+
+        if ics_url is None:
+            raise Exception("ics url not found")
+
+        if "kwu.lokal" in ics_url:
+            ics_url = ics_url.replace(
+                "http://kalender.kwu.lokal", "https://kalender.kwu-entsorgung.de"
+            )
+
+        # get ics file
+        r = session.get(ics_url, headers=HEADERS, verify=True)
+        r.raise_for_status()
+
+        # parse ics file
+        dates = self._ics.convert(r.text)
+
+        entries = []
+        # for d in dates:
+        #    entries.append(Collection(d[0], d[1]))
+        # return entries
+        for d in dates:
+            waste_type = d[1].strip()
+            next_pickup_date = d[0]
+
+            entries.append(
+                Collection(
+                    date=next_pickup_date,
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,115 @@
+from datetime import date, timedelta
+
+import requests
+from requests import RequestException
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentRequired,
+)
+
+TITLE = "City of Los Angeles, CA"
+DESCRIPTION = "Source script for Los Angeles, California waste collection services"
+URL = "https://www.lacitysan.org"
+COUNTRY = "us"
+TEST_CASES = {
+    "East Valley District Yard": {"street_address": "11050 Pendleton Street"},
+    "West Valley District Yard": {"street_address": "8840 Vanalden Avenue"},
+    "North Central District Yard": {"street_address": "452 North San Fernando Road"},
+    "South Los Angeles District Yard": {"street_address": "786 South Mission Road"},
+    "Harbor District Yard": {"street_address": "1400 North Gaffey Street"},
+    "West Los Angeles District Yard": {"street_address": "2027 Stoner Avenue"},
+}
+
+ICON_MAP = {
+    "BLACK BIN": Icons.GENERAL_WASTE,
+    "BLUE BIN": Icons.RECYCLING,
+    "GREEN BIN": Icons.ORGANIC,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Enter your street address exactly as it appears on your LA Sanitation bill. "
+        "The address must be within Los Angeles city limits."
+    )
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street_address": "Your complete street address without city/state (e.g. '22472 Denker Ave')"
+    }
+}
+
+
+class Source:
+    def __init__(self, street_address: str):
+        """Initialize the LA City waste collection source.
+
+        Args:
+            street_address: Street address in Los Angeles
+
+        Raises:
+            SourceArgumentRequired: If street_address is not provided
+        """
+        if not street_address:
+            raise SourceArgumentRequired(
+                "street_address",
+                "A valid street address in Los Angeles is required to look up collection schedule",
+            )
+
+        self._street_address = street_address
+        self._api_key = (
+            "YsvfDePjTDKtLl041Vz25jCbfjExMtCh"  # Public API key from LA City website
+        )
+        self._api_url = "https://api.lacity.org/boe_geoquery/addressvalidationservice"
+
+    def fetch(self) -> list[Collection]:
+        params = {
+            "address": self._street_address,
+            "status": "new",
+            "layerset": "neighborhoodinfo",
+            "apikey": self._api_key,
+        }
+
+        try:
+            response = requests.get(self._api_url, params=params)
+            response.raise_for_status()
+            data = response.json()
+
+        except RequestException as ex:
+            raise Exception(f"Error fetching collection data: {ex!s}") from ex
+
+        # Verify Address was found
+        if data["status"] != "exactMatch":
+            raise SourceArgumentException(
+                argument=self._street_address,
+                message=data["message"],
+            )
+
+        # Get Collection Day
+        weekday_map = {
+            "MONDAY": 0,
+            "TUESDAY": 1,
+            "WEDNESDAY": 2,
+            "THURSDAY": 3,
+            "FRIDAY": 4,
+        }
+        collection_day = data["layers"]["merge"]["day"]
+        collection_weekday = weekday_map[collection_day]
+
+        entries = []
+
+        # Get Next 2 Weeks for Collection Dates
+        today = date.today()
+        for i in range(14):  # Look ahead 2 weeks
+            check_date = today + timedelta(days=i)
+            if check_date.weekday() == collection_weekday:
+                for waste_type in ICON_MAP:
+                    entries.append(
+                        Collection(
+                            date=check_date,
+                            t=waste_type,
+                            icon=ICON_MAP.get(waste_type),
+                        )
+                    )
+        return entries

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

@@ -0,0 +1,39 @@
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Lake Macquarie City Council"
+DESCRIPTION = "Source for Lake Macquarie City Council, Australia."
+URL = "https://www.lakemac.com.au/"
+TEST_CASES = {
+    "TestcaseI": {"address": "te"},
+    "TestcaseII": {"address": "386 Pacific Highway, MURRAYS BEACH NSW 2281"},
+}
+
+ICON_MAP = {
+    "General waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Green waste": Icons.GARDEN,
+    "Bulk waste": Icons.GENERAL_WASTE,
+}
+
+HEADERS = {
+    "referer": "https://www.lakemac.com.au/For-residents/Waste-and-recycling/When-are-your-bins-collected"
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.lakemac.com.au",
+    headers=HEADERS,
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def fetch(self) -> list[Collection]:
+        return self._client.fetch(address=self._address)

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

@@ -0,0 +1,128 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "London Borough of Lambeth"
+DESCRIPTION = "Source for London Borough of Lambeth"
+URL = "https://www.lambeth.gov.uk/"
+
+TEST_CASES = {
+    "Sternhold Avenue": {"uprn": "100021893293"},
+    "Sibella Road": {"uprn": "100021889496"},
+    "Hoadly Road": {"uprn": "100021852695"},
+}
+
+API_URL = "https://wasteservice.lambeth.gov.uk/WhitespaceComms/GetServicesByUprn"
+
+ICON_MAP = {
+    "Domestic Food Collection Service": Icons.BIO_KITCHEN,
+    "Domestic Recycling Collection Service": Icons.GENERAL_WASTE,
+    "Domestic Refuse Collection Service": Icons.GENERAL_WASTE,
+    "Domestic Garden Collection Service": Icons.GARDEN,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "uprn": "Property UPRN (Unique Property Reference Number)",
+    },
+    "de": {
+        "uprn": "UPRN der Immobilie",
+    },
+    "it": {
+        "uprn": "UPRN della proprietà",
+    },
+    "fr": {
+        "uprn": "UPRN du bien",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "uprn": "Find your UPRN at https://www.findmyaddress.co.uk/",
+    },
+    "de": {
+        "uprn": "Finden Sie Ihre UPRN unter https://www.findmyaddress.co.uk/",
+    },
+    "it": {
+        "uprn": "Trova il tuo UPRN su https://www.findmyaddress.co.uk/",
+    },
+    "fr": {
+        "uprn": "Trouvez votre UPRN sur https://www.findmyaddress.co.uk/",
+    },
+}
+
+# Strict allowlist of valid waste collection services
+ALLOWED_SERVICES = set(ICON_MAP.keys())
+
+
+class Source:
+    def __init__(self, uprn: str):
+        self._uprn = str(uprn)
+
+    def fetch(self) -> list[Collection]:
+        payload = {
+            "uprn": self._uprn,
+            "includeEventTypes": False,
+            "includeFlags": True,
+        }
+
+        headers = {
+            "User-Agent": "Mozilla/5.0",
+            "Content-Type": "application/json",
+        }
+
+        try:
+            response = requests.post(
+                API_URL,
+                json=payload,
+                headers=headers,
+                timeout=30,
+            )
+            response.raise_for_status()
+        except requests.Timeout:
+            raise Exception("API request timed out") from None
+        except requests.RequestException as e:
+            raise Exception(f"API request failed: {e}") from e
+
+        try:
+            data = response.json()
+        except ValueError:
+            raise Exception("Invalid JSON response") from None
+
+        services = data.get("SiteServices")
+        if not services:
+            raise SourceArgumentNotFound("uprn", self._uprn)
+
+        entries = []
+
+        for item in services:
+            service_name = item.get("ServiceDescription")
+            next_date_str = item.get("NextCollectionDate")
+
+            if not service_name or not next_date_str:
+                continue
+
+            if service_name not in ALLOWED_SERVICES:
+                continue
+
+            try:
+                collection_date = datetime.datetime.strptime(
+                    next_date_str, "%d/%m/%Y"
+                ).date()
+            except ValueError:
+                continue
+
+            entries.append(
+                Collection(
+                    date=collection_date,
+                    t=service_name,
+                    icon=ICON_MAP.get(service_name, "mdi:trash-can"),
+                )
+            )
+
+        if not entries:
+            raise Exception("No valid waste collection entries found")
+
+        return entries