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

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

@@ -0,0 +1,162 @@
+import datetime
+import json
+import re
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Sector 27 - Datteln, Marl, Oer-Erkenschwick"
+DESCRIPTION = "Source for Muellkalender in Kreis RE."
+URL = "https://muellkalender.sector27.de"
+TEST_CASES = {
+    "Datteln": {"city": "Datteln", "street": "Am Bahnhof"},
+    "Datteln Im Overkamp": {"city": "Datteln", "street": "Im Overkamp"},
+    "Datteln range street": {
+        "city": "Datteln",
+        "street": "Ahsener Straße 113 - 161 (ungerade)",
+    },
+    "Marl": {"city": "Marl", "street": "Ahornweg"},
+    "Oer-Erkenschick": {"city": "Oer-Erkenschwick", "street": "An der Zechenbahn"},
+}
+
+CITIES = {
+    "Datteln": {"idCity": 9, "licenseKey": "DTTLN20137REKE382EHSE"},
+    "Marl": {"idCity": 3, "licenseKey": "MRL3102HBBUHENWIP"},
+    "Oer-Erkenschwick": {"idCity": 8, "licenseKey": "OSC1115KREHDFESEK"},
+}
+
+HEADERS = {"user-agent": "Mozilla/5.0"}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "city": "Ort",
+        "street": "Straße",
+    },
+}
+
+
+class Source:
+    def __init__(self, city, street):
+        self._city = city
+        self._street = street
+
+    def getviewYearRange(self):
+        yRange = []
+
+        now = datetime.datetime.now()
+
+        month = now.month
+        year = now.year
+
+        d = datetime.datetime(year, 1, 1, hour=12)
+
+        yRange.append(int(datetime.datetime.timestamp(d)))
+
+        # in november & december always fetch next year also
+        if month > 8:
+            d = datetime.datetime(year + 1, 1, 1, hour=12)
+            yRange.append(int(datetime.datetime.timestamp(d)))
+
+        return yRange
+
+    def _lookup_street_id(self, city):
+        """Resolve a street name to its sector27 street id.
+
+        The upstream ``searchForStreets`` endpoint appears to truncate the
+        result list after a handful of matches, so searching with the first
+        whitespace-separated token of the street name fails when the street
+        starts with a generic German article/preposition such as ``Im``,
+        ``Am``, ``An``, ``Auf``, ``Zum`` and the distinctive word is the
+        second one (e.g. ``"Im Overkamp"``).
+
+        To be robust we try each distinct token of the configured street and
+        look for an exact, case-insensitive, whitespace-stripped match in
+        any of the responses. The first match wins. Only if no token yields
+        a match do we surface a ``SourceArgumentNotFound(WithSuggestions)``
+        error.
+        """
+        if not self._street:
+            raise SourceArgumentNotFound("street", self._street)
+
+        target = self._street.strip().casefold()
+        # Preserve first-occurrence order while dropping duplicates.
+        tokens: list[str] = []
+        for token in self._street.split():
+            if token and token not in tokens:
+                tokens.append(token)
+
+        suggestions: dict[str, None] = {}
+
+        for token in tokens:
+            params = {
+                "idCity": city["idCity"],
+                "licenseKey": city["licenseKey"],
+                "searchFor": token,
+            }
+            r = requests.get(
+                "https://muellkalender.sector27.de/web/searchForStreets",
+                params=params,
+                headers=HEADERS,
+            )
+            r.raise_for_status()
+            entries = json.loads(extractJson(r.text))
+
+            for entry in entries:
+                name = entry.get("name", "").strip()
+                if not name:
+                    continue
+                suggestions[name] = None
+                if name.casefold() == target:
+                    return entry["id"]
+
+        if suggestions:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street", self._street, list(suggestions.keys())
+            )
+        raise SourceArgumentNotFound("street", self._street)
+
+    def fetch(self):
+        city = CITIES.get(self._city)
+        if city is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "city", self._city, list(CITIES.keys())
+            )
+
+        street_id = self._lookup_street_id(city)
+
+        args = {
+            "licenseKey": city["licenseKey"],
+            "cityId": city["idCity"],
+            "streetId": street_id,
+            "viewrange": "yearRange",
+        }
+
+        entries = []
+
+        for dt in self.getviewYearRange():
+            args["viewdate"] = dt
+
+            r = requests.get(
+                "https://muellkalender.sector27.de/web/fetchPickups",
+                params=args,
+                headers=HEADERS,
+            )
+            r.raise_for_status()
+            data = json.loads(extractJson(r.text))
+
+            for ts, pickups in data["pickups"].items():
+                for pickup in pickups:
+                    type = pickup["label"]
+                    pickupdate = datetime.date.fromtimestamp(int(ts))
+                    entries.append(Collection(pickupdate, type))
+
+        return entries
+
+
+def extractJson(text):
+    m = re.fullmatch(r"callbackFunc\((.*)\);", text)
+    return m.group(1) if m else text

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

@@ -0,0 +1,121 @@
+import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Sefton Council"  # Title will show up in README.md and info.md
+DESCRIPTION = "Source for Sefton Council, UK"  # Describe your source
+URL = "https://www.sefton.gov.uk/"  # Insert url to service homepage. URL will show up in README.md and info.md
+TEST_CASES = {  # Insert arguments for test cases to be used by test_sources.py script
+    "Issue2369": {
+        "house_number_or_name": "1",
+        "streetname": "Ken Mews",
+        "postcode": "L20 6GF",
+    },
+    "Housename": {
+        "house_number_or_name": "Gladstone House",
+        "streetname": "Rosemary Lane",
+        "postcode": "L37 3JB",
+    },
+    "Issue2496": {
+        "house_number_or_name": 22,
+        "streetname": "Elton Avenue",
+        "postcode": "L23 8UW",
+    },
+}
+
+API_URL = "https://www.sefton.gov.uk/bins-and-recycling/bins-and-recycling/when-is-my-bin-collection-day/"
+ICON_MAP = {
+    "RESIDUAL": Icons.GENERAL_WASTE,
+    "RECYCLING": Icons.RECYCLING,
+    "GREEN": Icons.ORGANIC,
+}
+
+# ### Arguments affecting the configuration GUI ####
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {  # Optional dictionary to describe how to get the arguments, will be shown in the GUI configuration form above the input fields, does not need to be translated in all languages
+    "en": "Using a browser, go to [sefton.gov.uk](https://www.sefton.gov.uk/bins-and-recycling/bins-and-recycling/when-is-my-bin-collection-day/). "
+    "For _Postcode_ and _Street name_ use the values you'd enter on Sefton's first page."
+    "Search, and then for _House Name or Number_ you need the value that comes before the street name you entered on the first screen."
+    "e.g. if your streetname is 'Liverpool Road' and the select box has an option of '1A Liverpool Road' enter '1A' as your _House Name or Number_."
+}
+
+PARAM_DESCRIPTIONS = {  # Optional dict to describe the arguments, will be shown in the GUI configuration below the respective input field
+    "en": {
+        "house_number_or_name": "House name or number",
+        "streetname": "Street name",
+        "postcode": "Postcode",
+    }
+}
+
+
+# ### End of arguments affecting the configuration GUI ####
+
+
+class Source:
+    def __init__(
+        self, house_number_or_name: str | int, streetname: str, postcode: str
+    ):  # argX correspond to the args dict in the source configuration
+        self._house_number_or_name = str(house_number_or_name).upper()
+        self._streetname = streetname
+        self._postcode = postcode
+
+    def fetch(self) -> list[Collection]:
+        with requests.Session() as sess:
+            request = sess.get(
+                "https://www.sefton.gov.uk/bins-and-recycling/bins-and-recycling/when-is-my-bin-collection-day/"
+            )
+
+            soup = BeautifulSoup(request.content, "html.parser")
+            hidden = soup.find_all("input", {"type": "hidden"}, limit=2)
+            payload = {x["name"]: x["value"] for x in hidden}
+            payload["Postcode"] = self._postcode
+            payload["Streetname"] = self._streetname
+            request = sess.post(
+                "https://www.sefton.gov.uk/bins-and-recycling/bins-and-recycling/when-is-my-bin-collection-day/",
+                data=payload,
+            )
+            # We should now have the page displaying the select list for addresses, parse again to find the form elements we need.
+            soup = BeautifulSoup(request.content, "html.parser")
+            hidden = soup.find_all("input", {"type": "hidden"})
+            payload = {x["name"]: x["value"] for x in hidden}
+            payload["action"] = "Select"
+            option_tags = soup.select("select option")
+            for option in option_tags:
+                if option.text.upper().strip().startswith(self._house_number_or_name):
+                    payload["selectedValue"] = option["value"]
+                    break
+            if "selectedValue" not in payload:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "houseNumberOrName",
+                    self._house_number_or_name,
+                    [option.text.strip() for option in option_tags],
+                )
+            request = sess.post(
+                "https://www.sefton.gov.uk/bins-and-recycling/bins-and-recycling/when-is-my-bin-collection-day/",
+                data=payload,
+            )
+            soup = BeautifulSoup(request.content, "html.parser")
+            tables = soup.find_all("table")
+            entries = []
+            if len(tables) > 0:
+                for table in tables:
+                    binType = table.td.text.split()[0]
+                    binCollectionDate = datetime.datetime.strptime(
+                        table.td.findNext("td").findNext("td").text, "%d/%m/%Y"
+                    ).date()
+                    entries.append(
+                        Collection(
+                            date=binCollectionDate,
+                            t=binType,
+                            icon=ICON_MAP.get(binType.upper()),
+                        )
+                    )
+            else:
+                raise Exception(
+                    "No entries could be parsed, check the Sefton website is working and your arguments exactly match what you enter online."
+                )
+
+        return entries

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

@@ -0,0 +1,198 @@
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import (
+    Collection,  # type: ignore[attr-defined]
+    Icons,
+)
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFound,
+    SourceArgumentRequired,
+)
+
+TITLE = "Selwyn District Council"
+DESCRIPTION = (
+    "Source for Selwyn District Council kerbside waste collection, New Zealand."
+)
+URL = "https://www.selwyn.govt.nz/"
+COUNTRY = "nz"
+TEST_CASES = {
+    # schedule 1 (Friday), with organics
+    "30 Tennyson Street Rolleston": {"address": "30 Tennyson Street Rolleston"},
+    # schedule 2 (Monday), with organics
+    "77 Gerald Street Lincoln": {"address": "77 Gerald Street Lincoln"},
+    # schedule 1 (Tuesday), with organics
+    "15 Meijer Drive Lincoln": {"address": "15 Meijer Drive Lincoln"},
+    # schedule 1 (Thursday), with organics
+    "22 Mclaughlins Road Darfield": {"address": "22 Mclaughlins Road Darfield"},
+    # schedule 2 (Monday), no organics service
+    "156 Leeston Road Springston": {"address": "156 Leeston Road Springston"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your address exactly as it appears in the address search on "
+    "Selwyn District Council's collection days and routes page, e.g. "
+    "'30 Tennyson Street Rolleston'."
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Address",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address within the Selwyn District, e.g. "
+        "'30 Tennyson Street Rolleston'.",
+    }
+}
+
+API_URL = (
+    "https://gis.selwyn.govt.nz/arcgis/rest/services/SDC_Public/"
+    "Refuse_address/MapServer/0/query"
+)
+
+# Waste-type labels.
+RUBBISH = "Rubbish"
+RECYCLING = "Recycling"
+ORGANIC = "Organics"
+
+ICON_MAP = {
+    RUBBISH: Icons.GENERAL_WASTE,
+    RECYCLING: Icons.RECYCLING,
+    ORGANIC: Icons.ORGANIC,
+}
+
+# Number of weeks of collections to generate.
+WEEKS_AHEAD = 8
+
+# Cap the disambiguation suggestions: a prefix match can return many properties.
+MAX_SUGGESTIONS = 10
+
+WEEKDAYS = {
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+    "saturday": 5,
+    "sunday": 6,
+}
+
+# Reference date for the council's two-weekly recycling cycle: a "week 1" Sunday.
+# Matches the anchor used by the council's own collection-day look-up widget.
+RECYCLING_ANCHOR = date(2024, 3, 17)
+
+
+def _label_for_charge(charge_type: str) -> str:
+    """Map a raw ``ChargeType`` value to a collapsed waste-type label.
+
+    Selwyn bills several weekly red-bin variants ("refuse uniform charge",
+    "rubbish 80 litre", "rubbish 240 litre", ...). They are all the same weekly
+    rubbish collection, so they collapse to a single label.
+    """
+    charge = charge_type.strip().lower()
+    if charge == "recycling":
+        return RECYCLING
+    if charge == "organic":
+        return ORGANIC
+    return RUBBISH
+
+
+def _recycling_week(d: date) -> int:
+    """Return the council's recycling-cycle week number (1 or 2) for a date.
+
+    Rubbish and organics are collected weekly; only recycling is fortnightly. A
+    property's recycling is collected in the weeks whose number equals its
+    ``COLLECTION_SCHEDULE``. The week number alternates every 7 days from
+    ``RECYCLING_ANCHOR`` -- the same calculation the council's website performs.
+    """
+    return ((d - RECYCLING_ANCHOR).days // 7) % 2 + 1
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address: str = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        if not self._address:
+            raise SourceArgumentRequired(
+                "address", "a street address within the Selwyn District is required"
+            )
+
+        # Case-insensitive prefix match on the full address. Escape single
+        # quotes for the ArcGIS SQL-style ``where`` clause.
+        escaped = self._address.lower().replace("'", "''")
+        params = {
+            "f": "json",
+            "where": f"LOWER(Address_full) LIKE '{escaped}%'",
+            "outFields": "ChargeType,COLLECTION_SCHEDULE,COLLECTION_DAY,Address_full",
+            "returnGeometry": "false",
+            # Cap the response: a short prefix can match many properties. We rely
+            # on the ambiguity error below to prompt the user for a longer prefix.
+            "resultRecordCount": 200,
+        }
+
+        r = requests.get(API_URL, params=params, timeout=30)
+        r.raise_for_status()
+        features = r.json().get("features", [])
+        if not features:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # A short fragment can match several distinct properties. ArcGIS result
+        # ordering is not guaranteed, so don't silently pick one. If the user's
+        # input is itself an exact (case-insensitive) full address, use it even
+        # when other properties share it as a prefix; otherwise ask the user to
+        # disambiguate with the matching addresses.
+        matched = sorted({f["attributes"]["Address_full"] for f in features})
+        if len(matched) > 1:
+            exact = [a for a in matched if a.lower() == self._address.lower()]
+            if not exact:
+                raise SourceArgAmbiguousWithSuggestions(
+                    "address", self._address, matched[:MAX_SUGGESTIONS]
+                )
+            target = exact[0]
+        else:
+            target = matched[0]
+        features = [
+            f for f in features if f["attributes"].get("Address_full") == target
+        ]
+
+        # Collapse the feature rows into one entry per waste-type label. Each
+        # property has at most one rubbish, one recycling and one organics charge.
+        bins: dict[str, dict] = {}
+        for feature in features:
+            attrs = feature["attributes"]
+            day = (attrs.get("COLLECTION_DAY") or "").strip().lower()
+            if day not in WEEKDAYS:
+                continue
+            label = _label_for_charge(attrs.get("ChargeType", ""))
+            schedule = (attrs.get("COLLECTION_SCHEDULE") or "").strip()
+            info = bins.setdefault(label, {"weekday": WEEKDAYS[day], "schedule": ""})
+            # Only the recycling row carries a meaningful schedule ("1"/"2").
+            if schedule in ("1", "2"):
+                info["schedule"] = schedule
+
+        if not bins:
+            raise SourceArgumentNotFound("address", self._address)
+
+        today = date.today()
+        entries: list[Collection] = []
+        for offset in range(WEEKS_AHEAD * 7):
+            day = today + timedelta(days=offset)
+            for label, info in bins.items():
+                if day.weekday() != info["weekday"]:
+                    continue
+                # Rubbish and organics are weekly; recycling is fortnightly and
+                # only falls in the weeks matching the property's schedule.
+                if label == RECYCLING:
+                    schedule = info["schedule"]
+                    if schedule not in ("1", "2"):
+                        continue
+                    if _recycling_week(day) != int(schedule):
+                        continue
+                entries.append(Collection(day, label, ICON_MAP[label]))
+
+        return entries

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

@@ -0,0 +1,80 @@
+import datetime
+import xml.etree.ElementTree
+
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.Sepan import SepanClient
+
+TITLE = "Koziegłowy/Objezierze/Oborniki"
+DESCRIPTION = "Source for Koziegłowy/Objezierze/Oborniki city garbage collection"
+URL = "https://sepan.remondis.pl"
+COUNTRY = "pl"
+TEST_CASES = {
+    "Street Name": {
+        "city": "Poznań",
+        "street_name": "ŚWIĘTY MARCIN",
+        "street_number": "2",
+    },
+}
+
+# Waste-type names and icons by report-table column position. This source's
+# report tables don't reliably expose parseable header text (unlike
+# zys_harmonogram_pl / alba_com_pl), so - as in the pre-refactor
+# implementation - rows are read positionally: row 1 = January ... row 12 =
+# December, column 1..7 = the fixed categories below.
+NAME_MAP = {
+    1: "Zmieszane odpady komunalne",
+    2: "Papier",
+    3: "Metale i tworzywa sztuczne",
+    4: "Szkło",
+    5: "Bioodpady",
+    6: "Drzewka świąteczne",
+    7: "Odpady wystawkowe",
+}
+
+ICON_MAP = {
+    1: Icons.GENERAL_WASTE,
+    2: Icons.PAPER,
+    3: Icons.RECYCLING,
+    4: Icons.GLASS,
+    5: Icons.ORGANIC,
+    6: Icons.CHRISTMAS_TREE,
+    7: Icons.BULKY,
+}
+
+
+def _base_urls() -> list[str]:
+    year = datetime.datetime.now().year
+    return [
+        f"https://sepan.remondis.pl/harmonogram{year}",
+        "https://sepan.remondis.pl/harmonogram",
+    ]
+
+
+class Source:
+    def __init__(self, city: str, street_name: str, street_number: str):
+        self._client = SepanClient(_base_urls())
+        self._address_id = self._client.resolve_address(
+            city, street_name, street_number
+        )
+
+    def fetch(self) -> list[Collection]:
+        html = self._client.fetch_report_html(self._address_id)
+        table_html = html[html.find("<table") : html.rfind("</table>") + 8]
+        tree = xml.etree.ElementTree.fromstring(table_html)  # nosec B314
+        year = datetime.date.today().year
+
+        entries = []
+        for row_index, row in enumerate(tree.findall(".//tr")):
+            if row_index > 0:
+                for cell_index, cell in enumerate(row.findall(".//td")):
+                    if cell_index > 0 and isinstance(cell.text, str):
+                        for day in cell.text.split(","):
+                            entries.append(
+                                Collection(
+                                    datetime.date(year, row_index - 1, int(day)),
+                                    NAME_MAP[cell_index],
+                                    ICON_MAP[cell_index],
+                                )
+                            )
+
+        return entries