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

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

@@ -0,0 +1,211 @@
+import logging
+from datetime import date, datetime
+
+from bs4 import BeautifulSoup
+from curl_cffi import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (  # type: ignore[attr-defined]
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Preston City Council"
+DESCRIPTION = "Source for preston.gov.uk services for Preston City Council, UK."
+URL = "https://preston.gov.uk"
+COUNTRY = "uk"
+SRV_URL = (
+    "https://selfservice.preston.gov.uk/service/Forms/FindMyNearest.aspx?Service=bins"
+)
+
+TEST_CASES = {
+    "Test_001": {"street": "town hall, lancaster road"},
+    "Test_002": {"street": "PR1 2RL", "uprn": "10002220003"},
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street": "Street / Postcode",
+        "uprn": "UPRN (optional)",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street": "Your street name or postcode (required). Used to search for your address.",
+        "uprn": "Your Unique Property Reference Number (optional). When provided alongside street/postcode, it picks the exact matching property from the search results. Leave blank if you are unsure.",
+    }
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your postcode or street name in the 'Street / Postcode' field. If your postcode returns multiple properties, find your UPRN at https://www.findmyaddress.co.uk/ and enter it in the optional 'UPRN' field to select the exact property."
+}
+
+ICON_MAP = {
+    "Food waste:": Icons.BIO_KITCHEN,
+    "Commercial -  general waste:": Icons.COMMERCIAL,
+    "Commercial -  cardboard and paper:": Icons.PAPER,
+    "Commercial - plastic cans and glass:": Icons.PLASTIC_PACKAGING,
+    "Commercial -  food waste:": Icons.BIO_KITCHEN,
+    "Black/grey bin (general waste):": Icons.GENERAL_WASTE,
+    "Yellow lidded recycling container (glass/cans/plastics):": Icons.PLASTIC_PACKAGING,
+    "Red lidded recycling container (paper/card):": Icons.PAPER,
+    "Brown bin (garden waste):": Icons.BIO_KITCHEN,
+}
+
+HEADER_MAP = {
+    "Food waste:": "Food Waste",
+    "Commercial -  general waste:": "General Waste (Commercial)",
+    "Commercial -  cardboard and paper:": "Cardboard (Commercial)",
+    "Commercial - plastic cans and glass:": "Plastic (Commercial)",
+    "Commercial -  food waste:": "Food Waste (Commercial)",
+    "Black/grey bin (general waste):": "General Waste (Black/Grey bin)",
+    "Yellow lidded recycling container (glass/cans/plastics):": "Glass/Cans/Plastics (Yellow bin)",
+    "Red lidded recycling container (paper/card):": "Cardboard/Paper (Red bin)",
+    "Brown bin (garden waste):": "Garden/Green Waste (Brown bin)",
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _extract_hidden_inputs(soup: BeautifulSoup) -> dict:
+    """Extract all hidden input fields from a BeautifulSoup page."""
+    params = {}
+    for inp in soup.find_all("input", {"type": "hidden"}):
+        name = inp.get("name")
+        value = inp.get("value", "")
+        if name:
+            params[name] = value
+    return params
+
+
+class Source:
+    def __init__(self, street="", uprn=""):
+        self._street = street
+        self._uprn = str(uprn)
+
+    def fetch(self) -> list:
+        if not self._street:
+            raise SourceArgumentNotFound(
+                argument="street",
+                value=self._street,
+            )
+
+        session = requests.Session(impersonate="chrome")
+
+        # Step 1: GET the initial page to obtain session cookies and hidden ASP.NET fields
+        r0 = session.get(SRV_URL)
+        r0.raise_for_status()
+        soup0 = BeautifulSoup(r0.text, features="html.parser")
+
+        # Step 2: POST the search request with address/postcode
+        params1 = _extract_hidden_inputs(soup0)
+        params1["__EVENTTARGET"] = "ctl00$MainContent$btnSearch"
+        params1["__EVENTARGUMENT"] = ""
+        params1["ctl00$MainContent$hdnService"] = "bins"
+        params1["ctl00$MainContent$txtAddress"] = self._street
+        params1["ctl00$MainContent$hdnUPRN"] = self._uprn
+
+        r1 = session.post(SRV_URL, data=params1)
+        r1.raise_for_status()
+        soup1 = BeautifulSoup(r1.text, features="html.parser")
+
+        # Check whether the search already returned collection data
+        cnt = soup1.select_one("span#MainContent_lblMoreCollectionDates")
+        if cnt and cnt.find_all("div", {"id": "container"}):
+            return self._parse(cnt)
+
+        # Step 3: Select from the address dropdown (triggered by ddlSearchResults change)
+        select_el = soup1.find("select", {"name": "ctl00$MainContent$ddlSearchResults"})
+        if not select_el:
+            raise SourceArgumentNotFound(
+                argument="street",
+                value=self._street,
+            )
+
+        options = [
+            opt
+            for opt in select_el.find_all("option")
+            if opt.get("value", "").startswith("170|")
+            or opt.get("value", "").count("|") >= 4
+        ]
+
+        if not options:
+            # Build suggestions from all non-placeholder options
+            all_opts = [
+                opt.text.strip()
+                for opt in select_el.find_all("option")
+                if opt.get("value", "") not in ("Make a selection from the list", "")
+            ]
+            raise SourceArgumentNotFoundWithSuggestions(
+                argument="street",
+                value=self._street,
+                suggestions=all_opts,
+            )
+
+        # Pick the best matching option
+        selected_option = options[0]
+        if self._uprn:
+            for opt in options:
+                if self._uprn in (opt.get("value", "") + opt.text):
+                    selected_option = opt
+                    break
+
+        if len(options) > 1 and not self._uprn:
+            _LOGGER.warning(
+                "Multiple addresses found for %r, using first: %s",
+                self._street,
+                selected_option.text.strip(),
+            )
+
+        selected_value = selected_option.get("value", "")
+
+        params2 = _extract_hidden_inputs(soup1)
+        params2["__EVENTTARGET"] = "ctl00$MainContent$ddlSearchResults"
+        params2["__EVENTARGUMENT"] = ""
+        params2["ctl00$MainContent$hdnService"] = "bins"
+        params2["ctl00$MainContent$txtAddress"] = self._street
+        params2["ctl00$MainContent$ddlSearchResults"] = selected_value
+
+        r2 = session.post(SRV_URL, data=params2)
+        r2.raise_for_status()
+        soup2 = BeautifulSoup(r2.text, features="html.parser")
+
+        cnt = soup2.select_one("span#MainContent_lblMoreCollectionDates")
+        if not cnt or not cnt.find_all("div", {"id": "container"}):
+            raise SourceArgumentNotFound(
+                argument="street",
+                value=self._street,
+            )
+
+        return self._parse(cnt)
+
+    @staticmethod
+    def _date(date_string: str) -> date | None:
+        try:
+            return datetime.strptime(date_string, "%A %d/%m/%Y").date()
+        except ValueError:
+            return None
+
+    @staticmethod
+    def _parse(cnt) -> list:
+        entries = []
+
+        for blk in cnt.find_all("div", {"id": "container"}):
+            header_sel = blk.select_one("ul > b")
+            if not header_sel:
+                continue
+            header_txt = header_sel.text.strip()
+
+            hdr = HEADER_MAP.get(header_txt) or header_txt.rstrip(":")
+            ico = ICON_MAP.get(header_txt)
+
+            for itm in blk.select("ul > li"):
+                date_span = itm.select_one("span")
+                if not date_span:
+                    continue
+                date_obj = Source._date(date_span.text.strip())
+                if date_obj is None:
+                    continue
+                entries.append(Collection(t=hdr, date=date_obj, icon=ico))
+
+        return entries

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

@@ -0,0 +1,217 @@
+import json
+import re
+from datetime import datetime
+from typing import Any
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "PreZero Bielsko-Biała"
+DESCRIPTION = "Source for PreZero Bielsko-Biała waste collection schedule"
+URL = "https://prezero-bielsko.pl/harmonogram-odbioru-odpadow/"
+
+TEST_CASES = {
+    "Test_001": {"street": "Krakowska", "house_number": "12"},
+    "Test_002": {"street": "1 Maja", "house_number": "10"},
+    "Test_003": {"street": "Bajki", "house_number": "12A"},
+    "Test_004": {"street": "Chabrowa", "house_number": "1B"},
+}
+
+API_URL = "https://prezero-bielsko.pl/harmonogramy/index.php"
+
+WASTE_TYPE_MAP = {
+    "kuchenne": "Bio",
+    "resztkowe": "Pozostałości po segregowaniu",
+    "makulatura": "Papier",
+    "szklo": "Szkło",
+    "mix": "Metale i tworzywa sztuczne",
+    "zielone": "Zielone",
+    "gabaryty": "Gabaryty",
+}
+
+ICON_MAP = {
+    "kuchenne": Icons.BIO_KITCHEN,
+    "resztkowe": Icons.GENERAL_WASTE,
+    "makulatura": Icons.NEWSPAPER,
+    "szklo": Icons.GLASS,
+    "mix": Icons.RECYCLING,
+    "zielone": Icons.GARDEN,
+    "gabaryty": Icons.BULKY,
+}
+
+# ### Arguments affecting the configuration GUI ####
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street": "Street",
+        "house_number": "House number",
+    },
+    "de": {
+        "street": "Straße",
+        "house_number": "Hausnummer",
+    },
+    "it": {
+        "street": "Via",
+        "house_number": "Numero civico",
+    },
+    "fr": {
+        "street": "Rue",
+        "house_number": "Numéro de maison",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street": "Street",
+        "house_number": "House number",
+    },
+    "de": {
+        "street": "Straße",
+        "house_number": "Hausnummer",
+    },
+    "it": {
+        "street": "Via",
+        "house_number": "Numero civico",
+    },
+    "fr": {
+        "street": "Rue",
+        "house_number": "Numéro de maison",
+    },
+}
+
+# ### End of arguments affecting the configuration GUI ####
+
+
+class Source:
+    def __init__(self, street: str, house_number: str):
+        self._city = "Bielsko-Biała"
+        self._street = street
+        self._house_number = house_number
+
+    def _extract_json_from_response(self, response_text: str) -> dict[str, Any]:
+        match = re.search(r"eval\((.*)\)", response_text)
+        if not match:
+            raise Exception("Server response does not match expected format.")
+
+        json_data = match.group(1).strip()
+        json_data = re.sub(r",\s*([\]}])", r"\1", json_data)
+        try:
+            return json.loads(json_data)
+        except json.JSONDecodeError as e:
+            raise Exception(
+                f"JSON parsing error: {e}\nReceived content: {json_data}"
+            ) from e
+
+    def _post_request(self, payload: dict[str, str]) -> dict[str, Any]:
+        headers = {
+            "accept": "*/*",
+            "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+            "x-requested-with": "XMLHttpRequest",
+        }
+
+        try:
+            response = requests.post(API_URL, headers=headers, data=payload)
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"API communication error: {e}") from e
+
+        return self._extract_json_from_response(response.text)
+
+    def _validate_api_response_data(
+        self, data: dict[str, Any], data_description: str
+    ) -> None:
+        if "dane" not in data or not isinstance(data["dane"], list):
+            raise Exception(
+                f"Error downloading {data_description}. Incorrect API response structure: {data}"
+            )
+
+    def _get_streets(self) -> list[str]:
+        payload = {
+            "option": "com_sita",
+            "view": "ulice",
+            "q": self._city,
+            "rok": str(datetime.now().year),
+        }
+        data = self._post_request(payload)
+        self._validate_api_response_data(data, "streets")
+
+        return [street["ulica"] for street in data["dane"] if "ulica" in street]
+
+    def _get_house_numbers(self) -> list[str]:
+        payload = {
+            "option": "com_sita",
+            "view": "numery",
+            "q": self._city,
+            "ulica": self._street,
+            "rok": str(datetime.now().year),
+        }
+        data = self._post_request(payload)
+        self._validate_api_response_data(
+            data, f"house numbers for street '{self._street}'"
+        )
+
+        return [house["numer"] for house in data["dane"] if "numer" in house]
+
+    def _get_symbol(self) -> str:
+        available_streets = self._get_streets()
+        street_lower = self._street.lower()
+
+        matched_street = next(
+            (street for street in available_streets if street.lower() == street_lower),
+            None,
+        )
+        if not matched_street:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street", self._street, available_streets
+            )
+
+        self._street = matched_street
+
+        available_numbers = self._get_house_numbers()
+        if self._house_number not in available_numbers:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "house_number", self._house_number, available_numbers
+            )
+
+        payload = {
+            "option": "com_sita",
+            "view": "typy",
+            "q": self._city,
+            "ulica": self._street,
+            "numer": self._house_number,
+            "rok": str(datetime.now().year),
+        }
+
+        data = self._post_request(payload)
+        self._validate_api_response_data(data, "symbol")
+
+        if not data["dane"]:
+            raise Exception(
+                f"Could not find symbol for the given address. API response data is empty: {data}"
+            )
+
+        return data["dane"][0]["symbol"]
+
+    def fetch(self) -> list[Collection]:
+        symbol = self._get_symbol()
+
+        payload = {
+            "option": "com_sita",
+            "view": "daty",
+            "q": symbol,
+            "rok": str(datetime.now().year),
+        }
+
+        data = self._post_request(payload)
+        self._validate_api_response_data(data, "schedule")
+
+        entries = []
+        for item in data["dane"]:
+            date_str = f"{datetime.now().year}-{item['data_m']}-{item['data_d']}"
+            date = datetime.strptime(date_str, "%Y-%m-%d").date()
+            waste_type = WASTE_TYPE_MAP.get(item["rodzaj"], "unknown")
+            icon = ICON_MAP.get(item["rodzaj"])
+            entries.append(Collection(date, waste_type, icon))
+
+        return entries

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

@@ -0,0 +1,149 @@
+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 = "Prince George's County, MD"
+DESCRIPTION = (
+    "Source for Prince George's County, Maryland curbside trash, recycling, "
+    "bulky trash, and yard trim collection."
+)
+URL = "https://www.princegeorgescountymd.gov/departments-offices/environment/waste-recycling/residential-collections"
+COUNTRY = "us"
+
+TEST_CASES = {
+    "6807 McCormick Rd, Upper Marlboro": {
+        "address": "6807 McCormick Rd, Upper Marlboro, MD"
+    },
+    "2607 Haney Ave, Suitland": {"address": "2607 Haney Ave, Suitland, MD"},
+}
+
+ICON_MAP = {
+    "Trash": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Bulky Trash": Icons.BULKY,
+    "Yard Trim": Icons.GARDEN,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Full street address including city and state (e.g. '1301 McCormick Dr, Upper Marlboro, MD')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+# Prince George's County Department of the Environment "Once-A-Week"
+# residential collection lookup layer. This is the same FeatureLayer that
+# backs the County's own public "Waste Collection Services" address tool
+# linked from the Residential Collections page (URL above).
+TRASH_LAYER_URL = (
+    "https://gisent.princegeorgescountymd.gov/gisonline/rest/services/"
+    "DoE/RRD_PROP_TRASH/MapServer/0"
+)
+
+WEEKDAYS = {
+    "Monday": 0,
+    "Tuesday": 1,
+    "Wednesday": 2,
+    "Thursday": 3,
+    "Friday": 4,
+    "Saturday": 5,
+    "Sunday": 6,
+}
+
+WEEKS_AHEAD = 26
+
+# Fields on the layer that hold a weekly day-of-service name. The
+# Wood-and-Tree-Debris field is intentionally excluded because it is always
+# "Call 311 to Schedule" (an on-demand service, not a recurring weekly
+# pickup), and there is no reliable "day" to project forward.
+DAY_FIELDS = {
+    "Trash_Day_of_Service1": "Trash",
+    "Trash_Day_of_Service2": "Trash",
+    "Recycle_Day_of_Service": "Recycling",
+    "Bulky_Day_of_Service": "Bulky Trash",
+    "Yard_Day_of_Service": "Yard Trim",
+}
+
+OUT_FIELDS = ",".join({*DAY_FIELDS, "Address"})
+
+
+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
+
+        try:
+            features = query_feature_layer(
+                TRASH_LAYER_URL,
+                geometry=location,
+                out_fields=OUT_FIELDS,
+            )
+        except ArcGisError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        attrs = self._select_feature(features)
+
+        entries: list[Collection] = []
+        seen_days: dict[str, set[str]] = {}
+        for field, waste_type in DAY_FIELDS.items():
+            day_name = (attrs.get(field) or "").strip().title()
+            if day_name not in WEEKDAYS:
+                continue
+            # Avoid duplicate weekly entries when Trash_Day_of_Service1 and
+            # Trash_Day_of_Service2 happen to name the same weekday.
+            seen = seen_days.setdefault(waste_type, set())
+            if day_name in seen:
+                continue
+            seen.add(day_name)
+            entries += self._weekly_dates(day_name, waste_type)
+
+        if not entries:
+            # The property was found but is not enrolled in any
+            # County-collected waste service (e.g. commercial/private-hauler
+            # address), so there is nothing meaningful to report.
+            raise SourceArgumentNotFound("address", self._address)
+
+        return entries
+
+    def _select_feature(self, features: list[dict]) -> dict:
+        # A point that falls exactly on a shared parcel-boundary vertex can
+        # intersect more than one polygon. Prefer the feature whose Address
+        # starts with the same house number as the requested address.
+        house_number = "".join(
+            ch for ch in self._address.split()[0] if ch.isdigit()
+        ).lstrip("0")
+        if house_number:
+            for attrs in features:
+                found_address = (attrs.get("Address") or "").strip()
+                found_house_number = found_address.split(" ")[0].lstrip("0")
+                if found_house_number == house_number:
+                    return attrs
+        return features[0]
+
+    @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/prodnik_si.py

@@ -0,0 +1,114 @@
+import json
+from datetime import datetime, timezone
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentExceptionMultiple
+
+TITLE = "Prodnik"
+DESCRIPTION = "Source for Prodnik."
+URL = "https://prodnik.si"
+TEST_CASES = {
+    "Test1": {
+        "customer_number": "!secret prodnik_si_customer_number",
+        "password": "!secret prodnik_si_password",
+    }
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": 'Go to "https://e.prodnik.si/Registracija" to register.'
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "customer_number": "Your customer number written on the bill.",
+        "password": "Your password created during the registration.",
+    }
+}
+
+ICON_MAP = {
+    "m": Icons.GENERAL_WASTE,
+    "b": Icons.ORGANIC,
+    "e": Icons.RECYCLING,
+    "k": Icons.BULKY,
+}
+
+BIN_TYPES = {
+    "m": "Mesani",
+    "b": "Bioloski",
+    "e": "Embalaza",
+    "k": "Kosovni",
+}
+
+
+LOGIN_URL = "https://e.prodnik.si/Prijava"
+BASE_URL = "https://e.prodnik.si/Domov"
+
+
+class Source:
+    def __init__(self, customer_number: str, password: str):
+        self._customer_number = customer_number
+        self._password = password
+
+    def fetch(self) -> list[Collection]:
+        s = requests.Session()
+
+        r = s.get(LOGIN_URL)
+        r.raise_for_status()
+        html = r.text
+
+        viewstate = self.extract_login(html, '__VIEWSTATE" value="')
+        viewstate_gen = self.extract_login(html, '__VIEWSTATEGENERATOR" value="')
+        event_validation = self.extract_login(html, '__EVENTVALIDATION" value="')
+
+        data = {
+            "__VIEWSTATE": viewstate,
+            "__VIEWSTATEGENERATOR": viewstate_gen,
+            "__EVENTVALIDATION": event_validation,
+            "ctl00$MainContentPlaceHolder$UcLogin1$ctrLogin$UserName": self._customer_number,
+            "ctl00$MainContentPlaceHolder$UcLogin1$ctrLogin$Password": self._password,
+            "__EVENTTARGET": "ctl00$MainContentPlaceHolder$UcLogin1$ctrLogin$LoginBtn",
+            "__EVENTARGUMENT": "",
+        }
+
+        r = s.post(LOGIN_URL, data=data)
+        r.raise_for_status()
+        if "Uporabniško ime oz. geslo ni pravilno." in r.text:
+            raise SourceArgumentExceptionMultiple(
+                ["customer_number", "password"], "Login failed: invalid credentials"
+            )
+
+        r = s.get(BASE_URL)
+        r.raise_for_status()
+        sched_html = r.text
+
+        json_data = self.extract_json_from_html(sched_html)
+        collections = json.loads(json_data)
+
+        entries = []
+        for collection in collections:
+            # Choosing only the sixth char from example: "Odvoz kosovnih odpadkov"
+            type_char = collection["Subject"][6]
+            if type_char not in BIN_TYPES:
+                continue
+            bin_type = BIN_TYPES.get(type_char)
+            icon = ICON_MAP.get(type_char)
+            start_str = collection.get("StartTime", "")
+            if start_str.startswith("/Date(") and start_str.endswith(")/"):
+                timestamp_str = start_str[len("/Date(") : -len(")/")]
+                ts = int(timestamp_str) / 1000
+                d = datetime.fromtimestamp(ts, tz=timezone.utc).date()
+                entries.append(Collection(date=d, t=bin_type, icon=icon))
+        return entries
+
+    def extract_login(self, text: str, marker: str) -> str:
+        idx = text.find(marker)
+        start = idx + len(marker)
+        end = text.find('"', start)
+        return text[start:end]
+
+    def extract_json_from_html(self, text: str) -> str:
+        marker = 'appointmentSettings":{"dataSource":ej.isJSON('
+        start = text.find(marker) + len(marker)
+        end = text.find("]", start) + 1
+        return text[start:end]