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

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

@@ -0,0 +1,119 @@
+import datetime
+import re
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Afval Wijzer"
+DESCRIPTION = "Source for all cities regions supported in mijnafvalwijzer.nl"
+URL = "https://www.mijnafvalwijzer.nl"
+TEST_CASES = {
+    "Eindhoven1": {"postcode": "5651AN", "number": "34", "add": "A"},
+    "Eindhoven2": {"postcode": "5651AN", "number": "34"},
+    "Tilburg": {"postcode": "5014NN", "number": "174"},
+    "Meierijstad": {"postcode": "5481LR", "number": "6"},
+    "Rotterdam": {"postcode": "3067AL", "number": "53"},
+}
+
+ICON_MAP = {
+    "Restafval": Icons.GENERAL_WASTE,
+    "Papier en karton": Icons.PAPER,
+    "Groente, Fruit en Tuinafval": Icons.ORGANIC,
+    "PMD": Icons.GLASS,
+    "Plastic, Metalen en Drankkartons": Icons.PLASTIC_PACKAGING,
+    "papier": Icons.PAPER,
+    "GFT": Icons.BIO_KITCHEN,
+    "GFT ": Icons.BIO_KITCHEN,
+    "restafval": Icons.GENERAL_WASTE,
+}
+
+# ### 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": "INPUT ARGUMENTS ARE THE SAME AS THE ONES YOU FILL IN FOR YOUR HOME ADDRESS AT: https://www.mijnafvalwijzer.nl/",
+}
+
+# ### End of arguments affecting the configuration GUI ####
+
+
+class Source:
+    def __init__(self, postcode, number, add=""):
+        self._postcode = postcode
+        self._number = number
+        if add is None:
+            self._add = ""
+        else:
+            self._add = add
+
+    def fetch(self):
+        s = requests.Session()
+
+        r = s.get(
+            URL
+            + "/nl/"
+            + self._postcode.replace(" ", "")
+            + "/"
+            + self._number.replace(" ", "")
+            + "/"
+            + self._add.replace(" ", "")
+        )
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        soup = soup.find("div", class_="block md:hidden")
+        years = soup.find_all("div", id=re.compile("^jaar-"), class_="ophaaldagen")
+
+        dict_month = {
+            "januari": 1,
+            "februari": 2,
+            "maart": 3,
+            "april": 4,
+            "mei": 5,
+            "juni": 6,
+            "juli": 7,
+            "augustus": 8,
+            "september": 9,
+            "oktober": 10,
+            "november": 11,
+            "december": 12,
+        }
+
+        date_day = []
+        date_month = []
+        date_year = []
+        types_list = []
+        for year in years:
+            year_int = int(year.get("id")[-4:])
+            # Scope the date/type lookup to this year's own container.
+            # Searching the whole page (`soup`) here pulls in the
+            # dates/types of *every* year present on the page for *each*
+            # year iteration, duplicating entries and mislabeling half of
+            # them with the wrong year whenever two "jaar-XXXX" blocks are
+            # present at once (e.g. around a year boundary). See GH #5064.
+            dates = year.find_all("span", class_="span-line-break")
+            for date in dates:
+                date_day.append(int(date.string.split()[1]))
+                date_month.append(dict_month[date.string.split()[2]])
+                date_year.append(year_int)
+            types = year.find_all("span", class_="afvaldescr")
+            for type in types:
+                types_list.append(type.string)
+
+        entries: list[Collection] = []
+
+        for day, month, year, bin_type in zip(
+            date_day, date_month, date_year, types_list, strict=False
+        ):
+            try:
+                entries.append(
+                    Collection(
+                        date=datetime.date(year, month, day),  # Collection date
+                        t=bin_type,  # Collection type
+                        icon=ICON_MAP.get(bin_type),  # Collection icon
+                    )
+                )
+            except Exception:
+                pass
+
+        return entries

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

@@ -0,0 +1,54 @@
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Mildura Rural City Council"
+DESCRIPTION = "Source for Mildura Rural City Council waste collection."
+URL = "https://www.mildura.vic.gov.au"
+TEST_CASES = {
+    "Stockmans Drive": {"street_address": "1 Stockmans Drive, Irymple VIC 3498"},
+    "Deakin Avenue": {"street_address": "76 Deakin Avenue, Mildura VIC 3500"},
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street_address": "Full street address including suburb and postcode, e.g. '1 Stockmans Drive, Irymple VIC 3498'",
+    }
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Go to <https://www.mildura.vic.gov.au/Explore/My-Neighbourhood> and make sure your address matches the auto-complete suggestions."
+}
+
+HEADERS = {
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "accept": "text/plain, */*; q=0.01",
+    "Referer": "https://www.mildura.vic.gov.au/Services/Waste-and-Recycling/My-bins/Find-your-bin-day",
+    "X-Requested-With": "XMLHttpRequest",
+}
+
+ICON_MAP = {
+    "Organics Waste": Icons.BIO_KITCHEN,
+    "Landfill Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Glass": Icons.GLASS,
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.mildura.vic.gov.au",
+    argument_name="street_address",
+    headers=HEADERS,
+    use_curl_cffi=True,
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(self, street_address: str):
+        self._street_address = street_address
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def fetch(self) -> list[Collection]:
+        return self._client.fetch(address=self._street_address)

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

@@ -0,0 +1,98 @@
+import json
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup as bs
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+
+# Ronneby Miljöteknik, Blekinge Sweden
+#
+# The public URL is http://www.fyrfackronneby.se/hamtningskalender/
+# However, this uses an iframe from https://kalender.fyrfackronneby.se which is the
+# actual service providing the bin data.
+#
+# One first has to do a search since they put an ID in the list of
+# search results which is required when sending the request to get the
+# bin data. The data then comes injected into a script tag as it's
+# normally used to build a browsable calendar for easy viewing.
+#
+# Bins in this municipality have four types of waste each, and each
+# house has 2 bins, example raw data for the two bins:
+#
+# { title: 'Kärl 1 –  373 liter: Mat, Brännbart, färgat glas, tidningar.', start: '2023-09-12' },
+# { title: 'Kärl 2 –  373 liter: Plast, pappersförpackningar, ofärgat glas, metall.', start: '2023-09-05' },
+#
+# The API will return about a years worth of bin collection dates
+# and only the dates will change, title remains the same for the two
+# bins. First one being Food, Burnables, Colored glass and Newspapers,
+# and the second is Plastics, Cardboard, Non-colored glass and Metal.
+#
+# Note: This API does not apply for apartment buildings, municipal/state
+# services or similar types of buildings as those do not have the same
+# types of bins as regular houses. There is currently no known API for
+# those bins, only for the so called "Fyrfack" bins (meaning four slots).
+#
+
+TITLE = "Ronneby Miljöteknik"
+DESCRIPTION = "Source for Ronneby Miljöteknik waste collection."
+URL = "http://www.fyrfackronneby.se"
+TEST_CASES = {"Home": {"street_address": "Hjortsbergavägen 16, Johannishus"}}
+
+API_URL = "http://www.fyrfackronneby.se/hamtningskalender/"
+
+
+class Source:
+    def __init__(self, street_address):
+        addr_parts = street_address.split(",")
+        self._street_address = addr_parts[0]
+        self._city = addr_parts[1].lstrip()
+
+    def fetch(self):
+        data = {"search_address": self._street_address}
+        headers = {
+            "Accept-Encoding": "identity",
+            "Accept": "*/*",
+            "Accept-Language": "sv-SE,sv;q=0.9",
+            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        }
+        response = requests.post(
+            "https://kalender.fyrfackronneby.se/search_suggestions.php",
+            data=data,
+            headers=headers,
+        )
+
+        soup = bs(response.text, "html.parser")
+        pickup_id = False
+        for el_addr in soup.find_all("span", attrs={"class": "address"}):
+            if el_addr.string == self._street_address:
+                for el_addr_sib in el_addr.next_siblings:
+                    if el_addr_sib.name == "span" and el_addr_sib.string == self._city:
+                        pickup_id = el_addr.parent["id"]
+                        break
+                if pickup_id:
+                    break
+        if not pickup_id:
+            return []
+
+        data = {
+            "chosen_address": f"{self._street_address} {self._city}",
+            "chosen_address_pickupid": pickup_id,
+        }
+        response = requests.post(
+            "https://kalender.fyrfackronneby.se/get_data.php",
+            data=data,
+            headers=headers,
+        )
+
+        entries = []
+        for entry in re.findall(r"{.title:[^}]+}", response.text):
+            json_entry = json.loads(
+                re.sub(r"(title|start):", r'"\1":', entry.replace("'", '"'))
+            )
+            # Same icon always, due to two bins both being various recycled things
+            icon = "mdi:recycle"
+            waste_type = json_entry["title"].split(":")[1].lstrip()
+            pickup_date = datetime.fromisoformat(json_entry["start"]).date()
+            entries.append(Collection(date=pickup_date, t=waste_type, icon=icon))
+        return entries

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

@@ -0,0 +1,144 @@
+import datetime
+
+from curl_cffi import requests
+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 = "Mill Valley Refuse Service"
+DESCRIPTION = (
+    "Source for Mill Valley Refuse Service (MVRS), Marin County, California, USA."
+)
+URL = "https://www.millvalleyrefuse.com"
+
+TEST_CASES = {
+    "Whole service area": {},
+    "With pickup day (Wednesday)": {"pickup_day": "Wednesday"},
+    "With pickup day (Tuesday)": {"pickup_day": "Tuesday"},
+}
+
+COUNTRY = "us"
+
+# MVRS publishes one alternating-week residential recycling schedule for its
+# whole service area as three public Google Calendars, embedded on
+# https://www.millvalleyrefuse.com/residential-services . Container recycling
+# and paper recycling are collected on alternating weeks (citywide); garbage and
+# compost are weekly on each address's normal route day and are not published in
+# a machine-readable feed.
+RECYCLING_CALENDARS = {
+    "Container Recycling": (
+        "https://calendar.google.com/calendar/ical/"
+        "uokfjeogcqe0daugrn58mvkgo0%40group.calendar.google.com/public/basic.ics"
+    ),
+    "Paper Recycling": (
+        "https://calendar.google.com/calendar/ical/"
+        "d5mdlvop2qp45vmstm6gs5p1kg%40group.calendar.google.com/public/basic.ics"
+    ),
+}
+# Office-closure / holiday service notices.
+HOLIDAY_CALENDAR = (
+    "https://calendar.google.com/calendar/ical/"
+    "millvalleyrefuse%40gmail.com/public/basic.ics"
+)
+
+ICON_MAP = {
+    "Container Recycling": Icons.RECYCLING,
+    "Paper Recycling": Icons.PAPER,
+}
+
+# Number of days after the Sunday that starts each collection week.
+_WEEKDAY_OFFSETS = {
+    "Sunday": 0,
+    "Monday": 1,
+    "Tuesday": 2,
+    "Wednesday": 3,
+    "Thursday": 4,
+    "Friday": 5,
+    "Saturday": 6,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "No address lookup is required. Mill Valley Refuse Service publishes a "
+        "single alternating-week recycling schedule for its whole service area "
+        "(Mill Valley, Corte Madera, Tiburon, Belvedere, Strawberry and "
+        "unincorporated Marin). Optionally set 'pickup_day' to the weekday your "
+        "street is serviced so each collection lands on your actual pickup day "
+        "instead of the start of the week."
+    )
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "pickup_day": "Pickup Day",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "pickup_day": (
+            "The weekday your address is serviced (e.g. 'Wednesday'). MVRS "
+            "collects Monday-Friday depending on your street. If omitted, each "
+            "recycling week is marked on the Sunday it begins."
+        ),
+    }
+}
+
+
+def _weekly_collections(
+    dates: list[datetime.date], waste_type: str, offset: int
+) -> list[Collection]:
+    """Collapse a stream's per-day ICS events into one entry per week.
+
+    MVRS marks each alternating recycling week with all-day calendar events.
+    Group every event date by the Sunday that starts its week, then emit a
+    single collection per week - shifted by ``offset`` days so it falls on the
+    resident's pickup weekday (0 = the week-start Sunday).
+    """
+    week_starts = {
+        # date.isoweekday(): Mon=1 .. Sun=7  ->  Sun%7=0, Mon%7=1, ...
+        d - datetime.timedelta(days=d.isoweekday() % 7)
+        for d in dates
+    }
+    return [
+        Collection(
+            ws + datetime.timedelta(days=offset),
+            waste_type,
+            icon=ICON_MAP.get(waste_type),
+        )
+        for ws in sorted(week_starts)
+    ]
+
+
+class Source:
+    def __init__(self, pickup_day: str | None = None):
+        if pickup_day is not None:
+            match = [
+                d for d in _WEEKDAY_OFFSETS if d.lower() == pickup_day.strip().lower()
+            ]
+            if not match:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "pickup_day", pickup_day, list(_WEEKDAY_OFFSETS)
+                )
+            pickup_day = match[0]
+        self._pickup_day = pickup_day
+        self._ics = ICS()
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session(impersonate="chrome")
+        offset = _WEEKDAY_OFFSETS[self._pickup_day] if self._pickup_day else 0
+        entries: list[Collection] = []
+
+        for waste_type, url in RECYCLING_CALENDARS.items():
+            r = session.get(url)
+            r.raise_for_status()
+            dates = [d for d, _ in self._ics.convert(r.text)]
+            entries.extend(_weekly_collections(dates, waste_type, offset))
+
+        r = session.get(HOLIDAY_CALENDAR)
+        r.raise_for_status()
+        for d, title in self._ics.convert(r.text):
+            icon = Icons.EVENT if "as usual" in title.lower() else Icons.NO_COLLECTION
+            entries.append(Collection(d, title, icon=icon))
+
+        return entries

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

@@ -0,0 +1,79 @@
+from typing import ClassVar
+
+from waste_collection_schedule import Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.RiSKommunalAT import RiSKommunalSource
+
+TITLE = "Gemeinde Mils"
+DESCRIPTION = "Source for Gemeinde Mils, Tyrol, Austria."
+URL = "https://mils-tirol.at"
+COUNTRY = "at"
+SOURCE_CODEOWNERS = ["@bbr111"]
+
+TEST_CASES: dict[str, dict] = {
+    "Fichtenweg 21": {
+        "strasse": "Fichtenweg",
+        "hausnummer": "21",
+    },
+    "Dorfplatz 1": {
+        "strasse": "Dorfplatz",
+        "hausnummer": "1",
+    },
+}
+
+ICON_MAP = {
+    "Biomüll": Icons.ORGANIC,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Altpapier&Kleinkartons": Icons.PAPER,
+    "Problemstoffsammlung": Icons.HAZARDOUS,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "strasse": "Street",
+        "hausnummer": "House number",
+    },
+    "de": {
+        "strasse": "Straße",
+        "hausnummer": "Hausnummer",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "strasse": "Street name as listed in the Mils waste calendar dropdown.",
+        "hausnummer": "House number as listed in the Mils waste calendar dropdown.",
+    },
+    "de": {
+        "strasse": "Straßenname wie in der Abfallkalender-Auswahl von Mils aufgeführt.",
+        "hausnummer": "Hausnummer wie in der Abfallkalender-Auswahl von Mils aufgeführt.",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Open https://mils-tirol.at/Service/Dienstleistungen/Abfallkalender, pick "
+        "your street and house number from the dropdowns, and use the same values "
+        "for 'strasse' and 'hausnummer'."
+    ),
+    "de": (
+        "Öffnen Sie https://mils-tirol.at/Service/Dienstleistungen/Abfallkalender, "
+        "wählen Sie Ihre Straße und Hausnummer aus den Dropdown-Menüs, und "
+        "verwenden Sie dieselben Werte für 'strasse' und 'hausnummer'."
+    ),
+}
+
+
+class Source(RiSKommunalSource):
+    BASE_URL = "https://mils-tirol.at"
+    ICON_MAP = ICON_MAP
+    SELECTION_URL = "https://mils-tirol.at/Service/Dienstleistungen/Abfallkalender"
+    LOOKAHEAD_DAYS = 365
+    MAX_PAGES = 30
+    QUERY_PARAMS: ClassVar = {
+        "sprache": "1",
+        "menuonr": "226285523",
+    }
+
+    def __init__(self, strasse: str, hausnummer: str | int):
+        super().__init__(strasse=strasse, hausnummer=hausnummer)

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

@@ -0,0 +1,110 @@
+# modified version of bexley_gov_uk.py
+
+from datetime import datetime
+from time import time_ns
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Milton Keynes council"
+DESCRIPTION = "Source for Milton Keynes council."
+URL = "milton-keynes.gov.uk"
+TEST_CASES = {
+    "North Row, Central": {"uprn": 25032037},
+    "Adelphi Street, Campbell Park": {"uprn": 25044504},
+}
+
+
+ICON_MAP = {
+    "REFUSE": Icons.GENERAL_WASTE,
+    "RECYCLE": Icons.RECYCLING,
+    "RECYCLING": Icons.RECYCLING,
+    "FOOD": Icons.BIO_KITCHEN,
+    "GARDEN": Icons.GARDEN,
+}
+
+
+SITE_URL = (
+    "https://mycouncil.milton-keynes.gov.uk/service/Waste_Collection_Round_Checker"
+)
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn: str = str(uprn)
+
+    def fetch(self):
+        s = requests.Session()
+
+        # Set up session
+        timestamp = time_ns() // 1_000_000  # epoch time in milliseconds
+        s.get(
+            "https://mycouncil.milton-keynes.gov.uk/apibroker/domain/mycouncil.milton-keynes.gov.uk",
+            params={
+                "_": timestamp,
+            },
+            headers=HEADERS,
+        )
+
+        # This request gets the session ID
+        sid_request = s.get(
+            "https://mycouncil.milton-keynes.gov.uk/authapi/isauthenticated",
+            params={
+                "uri": "https://mycouncil.milton-keynes.gov.uk/service/Waste_Collection_Round_Checker",
+                "hostname": "mycouncil.milton-keynes.gov.uk",
+                "withCredentials": "true",
+            },
+        )
+        sid_data = sid_request.json()
+        sid = sid_data["auth-session"]
+
+        # This request retrieves the schedule
+        timestamp = time_ns() // 1_000_000  # epoch time in milliseconds
+        payload = {"formValues": {"Section 1": {"uprnCore": {"value": self._uprn}}}}
+        schedule_request = s.post(
+            "https://mycouncil.milton-keynes.gov.uk/apibroker/runLookup",
+            headers=HEADERS,
+            params={
+                # "id": "61320b2acf8a3",
+                "id": "64d9feda3a507",
+                "repeat_against": "",
+                "noRetry": "false",
+                "getOnlyTokens": "undefined",
+                "log_id": "",
+                "app_name": "AF-Renderer::Self",
+                "_": str(timestamp),
+                "sid": str(sid),
+            },
+            json=payload,
+        )
+
+        rowdata = schedule_request.json()["integration"]["transformed"]["rows_data"]
+
+        # Extract bin types and next collection dates
+        entries = []
+        for _index, item in rowdata.items():
+            # print(item)
+            bin_type = item["AssetTypeName"]
+            icon = None
+
+            for key, icon_name in ICON_MAP.items():
+                if (
+                    key in item["AssetTypeName"].upper()
+                    or key in item["TaskTypeName"].upper()
+                    or key in item["ServiceName"].upper()
+                ):
+                    icon = icon_name
+                    break
+
+            dates = [
+                datetime.strptime(item["NextInstance"], "%Y-%m-%d").date(),
+                datetime.strptime(item["LastInstance"], "%Y-%m-%d").date(),
+            ]
+            for date in dates:
+                entries.append(
+                    Collection(t=bin_type, date=date, icon=icon),
+                )
+        return entries