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

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

@@ -0,0 +1,182 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequiredWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Stadt Frankenberg (Eder)"
+DESCRIPTION = "Source for Stadt Frankenberg (Eder)."
+URL = "https://www.frankenberg.de/"
+TEST_CASES = {
+    "Viermünden": {"district": "Viermünden"},
+    "FKB-Kernstadt, Futterhof": {"district": "FKB-Kernstadt", "street": "Futterhof"},
+}
+
+ICON_MAP = {
+    "Trash": Icons.GENERAL_WASTE,
+    "Glass": Icons.GLASS,
+    "Bio": Icons.ORGANIC,
+    "Paper": Icons.PAPER,
+    "Recycle": Icons.RECYCLING,
+}
+
+
+API_URL = "https://abfall.frankenberg.de/online-dienste/"
+
+
+class Source:
+    def __init__(self, district: str, street: str | None = None):
+        self._district: str = district
+        self._street: str | None = street
+        self._ics = ICS(regex=r"(.*) am \d{2}.\d{2}.\d{4}")
+        self._district_id: str | None = None
+        self._street_id: str | None = None
+
+    def _match_district(self, district: str) -> bool:
+        return district.lower().replace(" ", "").replace('"', "").replace(
+            "-", ""
+        ) == self._district.lower().replace(" ", "").replace('"', "").replace("-", "")
+
+    def _match_street(self, street: str) -> bool:
+        if self._street is None:
+            return False
+
+        return street.lower().replace(" ", "").replace('"', "").replace(
+            "-", ""
+        ).replace("str.", "straße").replace("straße", "strasse").replace(
+            ".", ""
+        ) == self._street.lower().replace(" ", "").replace('"', "").replace(
+            "-", ""
+        ).replace("str.", "straße").replace("straße", "strasse").replace(".", "")
+
+    def fetch(self) -> list[Collection]:
+        fresh_ids = False
+        if self._district_id is None:
+            fresh_ids = True
+            self._get_ids()
+        try:
+            return self._get_collections()
+        except Exception:
+            if fresh_ids:
+                raise
+            self._get_ids()
+            return self._get_collections()
+
+    def _get_collections(
+        self,
+    ) -> list[Collection]:
+        now = datetime.now()
+        entries = self._get_collections_by_year(now.year)
+        if now.month != 12:
+            return entries
+        try:
+            entries.extend(self._get_collections_by_year(now.year + 1))
+        except Exception:
+            pass
+        return entries
+
+    def _get_collections_by_year(self, year: int) -> list[Collection]:
+        if self._street_id is not None:
+            data = {
+                "year": year,
+                "ak_bezirk": 1,
+                "ak_ortsteil": self._district_id,
+                "ak_strasse": self._street_id,
+                "alle_arten": "",
+                "datum_von": datetime(year, 1, 1).strftime("%d.%m.%Y"),
+                "datum_bis": datetime(year, 12, 31).strftime("%d.%m.%Y"),
+            }
+        else:
+            data = {
+                "year": year,
+                "ak_bezirk": 1,
+                "ak_ortsteil": self._district_id,
+                "alle_arten": "",
+                "datum_von": datetime(year, 1, 1).strftime("%d.%m.%Y"),
+                "datum_bis": datetime(year, 12, 31).strftime("%d.%m.%Y"),
+            }
+
+        r = requests.post(
+            "https://abfall.frankenberg.de/module/abfallkalender/generate_ical.php",
+            data=data,
+        )
+
+        r.raise_for_status()
+
+        dates = self._ics.convert(r.text)
+        entries = []
+        for d in dates:
+            entries.append(Collection(d[0], d[1], ICON_MAP.get(d[1])))
+
+        return entries
+
+    def _get_ids(self) -> None:
+        r = requests.get(
+            "https://abfall.frankenberg.de/module/abfallkalender/get_ortsteile.php",
+            params={"bez_id": 1},
+        )
+        r.raise_for_status()
+        # f.ak_ortsteil.options[0].text = 'Bitte wählen';f.ak_ortsteil.length = 2;f.ak_ortsteil.options[1].value = '1-1';
+        result = r.text.split(";")[
+            1:-2
+        ]  # remove first element (Bitte wählen) and last element (selectedIndex)
+
+        self._district_id = None
+        district_names = []
+
+        for i in range(0, len(result), 3):
+            id = result[i + 1].split("'")[1]
+            name = result[i + 2].split("'")[1]
+            district_names.append(name)
+            if self._match_district(name):
+                self._district_id = id
+                break
+
+        if self._district_id is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                argument="district",
+                value=self._district,
+                suggestions=district_names,
+            )
+
+        if not self._district_id.endswith("-0"):
+            self._get_street_id()
+
+    def _get_street_id(self) -> None:
+        if not self._district_id:
+            raise ValueError("No district id found")
+        r = requests.get(
+            "https://abfall.frankenberg.de/module/abfallkalender/get_strassen.php",
+            params={"ot_id": self._district_id.split("-")[0]},
+        )
+        r.raise_for_status()
+
+        result = r.text.split(";")[
+            1:-2
+        ]  # remove first element (Bitte wählen) and last element (selectedIndex)
+
+        names = []
+        self._street_id = None
+
+        for i in range(0, len(result), 3):
+            id = result[i + 1].split(" = ")[1]
+            name = result[i + 2].split("'")[1]
+            names.append(name)
+            if self._match_street(name):
+                self._street_id = id
+                break
+
+        if self._street_id is None:
+            if self._street is None:
+                raise SourceArgumentRequiredWithSuggestions(
+                    argument="street",
+                    reason="street is required for this district",
+                    suggestions=names,
+                )
+            raise SourceArgumentNotFoundWithSuggestions(
+                argument="street", value=self._street, suggestions=names
+            )

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

@@ -0,0 +1,133 @@
+import time
+from datetime import datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.Pozi import query_geojson_zones
+
+TITLE = "Frankston City Council"  # Title will show up in README.md and info.md
+DESCRIPTION = "Source script for frankston.vic.gov.au"  # Describe your source
+URL = "https://frankston.gov.au"  # 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
+    "45r Wedge Rd": {"address": "45r Wedge Rd, Carrum Downs Vic"},  # Monday
+    "300 Wedge Rd": {
+        "address": "300 Wedge Rd, Skye Vic"
+    },  # Monday, but inverse recycling week to 45r Wedge Rd
+    "66 Skye Rd": {"address": "66 Skye Rd, Skye Vic"},  # Tuesday
+    "160 North Rd": {"address": "160 North Road, Langwarrin Vic"},  # Wednesday
+    "65 Golf Links Rd": {"address": "65 Golf Links Rd, Frankston Vic"},  # Thursday
+    "107 Nepean Highway": {"address": "107 Nepean Highway, Seaford Vic"},  # Friday
+}
+
+API_URL = "https://www.frankston.vic.gov.au/My-Property/Waste-and-recycling/My-bins/Bin-collections"
+ICON_MAP = {
+    "Rubbish": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Green Waste": Icons.GARDEN,
+    "Glass": Icons.GLASS,
+}
+
+
+class Source:
+    def __init__(
+        self, address
+    ):  # argX correspond to the args dict in the source configuration
+        self._address = address
+
+    def get_collections(self, collection_day, weeks, start_date):
+        weeks = int(weeks)
+        collection_day = time.strptime(collection_day, "%A").tm_wday
+        today = datetime.now().date()
+        start_date = datetime.strptime(start_date, "%Y-%m-%d").date()
+
+        # Calculate days until the next collection day
+        days_until_next_collection = (collection_day - today.weekday() + 7) % 7
+        next_collect = today + timedelta(days=days_until_next_collection)
+
+        # Calculate the number of days from the start date to the next collection day
+        days_from_start = (next_collect - start_date).days
+
+        # Adjust the next collection day if not aligned with the collection cycle
+        if days_from_start % (weeks * 7) != 0:
+            days_until_aligned = (weeks * 7) - (days_from_start % (weeks * 7))
+            next_collect += timedelta(days=days_until_aligned)
+
+        next_dates = [next_collect]
+
+        # Generate the subsequent collection dates
+        for _i in range(1, 4 // weeks):
+            next_collect += timedelta(days=weeks * 7)
+            next_dates.append(next_collect)
+
+        return next_dates
+
+    def fetch(self):
+        # Get latitude & longitude of address
+        url = (
+            "https://api.geocode.earth/v1/autocomplete?text="
+            + self._address
+            + "&layers=address,street&boundary.gid=whosonfirst:county:102048609&api_key=ge-39bfbedc55be11c0"
+        )
+
+        r = requests.get(url)
+        r.raise_for_status()
+
+        long_lat = r.json()["features"][0]["geometry"]["coordinates"]
+        zoneUrl = "https://connect.pozi.com/userdata/frankston-publisher/Community/Kerbside_Garbage_Collection_(Widget).json"
+
+        waste_schedule = query_geojson_zones(zoneUrl, long_lat[1], long_lat[0])
+
+        entries = []
+        for next_date in self.get_collections(
+            waste_schedule["rub_day"],
+            waste_schedule["rub_weeks"],
+            waste_schedule["rub_start"],
+        ):
+            entries.append(
+                Collection(
+                    date=next_date,
+                    t="Rubbish",
+                    icon=ICON_MAP.get("Rubbish"),
+                )
+            )
+
+        for next_date in self.get_collections(
+            waste_schedule["rec_day"],
+            waste_schedule["rec_weeks"],
+            waste_schedule["rec_start"],
+        ):
+            entries.append(
+                Collection(
+                    date=next_date,
+                    t="Recycling",
+                    icon=ICON_MAP.get("Recycling"),
+                )
+            )
+
+        for next_date in self.get_collections(
+            waste_schedule["grn_day"],
+            waste_schedule["grn_weeks"],
+            waste_schedule["grn_start"],
+        ):
+            entries.append(
+                Collection(
+                    date=next_date,
+                    t="Green Waste",
+                    icon=ICON_MAP.get("Green Waste"),
+                )
+            )
+
+        for next_date in self.get_collections(
+            waste_schedule["gls_day"],
+            waste_schedule["gls_weeks"],
+            waste_schedule["gls_start"],
+        ):
+            entries.append(
+                Collection(
+                    date=next_date,
+                    t="Glass",
+                    icon=ICON_MAP.get("Glass"),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,143 @@
+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 (
+    IntraMapsError,
+    IntraMapsSearchError,
+    MapsClient,
+    MapsClientConfig,
+    extract_panel_fields,
+)
+
+TITLE = "Fraser Coast Regional Council"
+DESCRIPTION = "Source for Fraser Coast Regional Council waste collection."
+URL = "https://www.frasercoast.qld.gov.au"
+COUNTRY = "au"
+
+TEST_CASES = {
+    "Arbornine Road Glenwood": {"address": "57 Arbornine Road Glenwood"},
+    "Tavistock Street Torquay": {"address": "77 Tavistock Street Torquay"},
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your street address including suburb "
+    "(e.g. '57 Arbornine Road Glenwood'). "
+    "Search at https://www.frasercoast.qld.gov.au/Services/Online-Services/Check-your-bin-day",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address with suburb (e.g. '57 Arbornine Road Glenwood')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+INTRAMAPS_CONFIG = MapsClientConfig(
+    base_url="https://fcrc.spatial.t1cloud.com",
+    instance="spatial/IntraMaps",
+    config_id="e003842b-3af0-44a7-8bd8-45f9880f2c30",
+    project="95d8904e-e9ef-4cac-88b5-def885f74f4d",
+    lite_config_id="3727d4c0-1e2e-4eff-9669-b89f3a1919fe",
+    module_id="b4b2af30-9b10-41a9-b9c9-3e253e2563a1",
+    selection_layer_filter="93ccc583-6119-435f-845e-33deae245002",
+    default_selection_layer="93ccc583-6119-435f-845e-33deae245002",
+)
+
+WEEKDAYS = {
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+    "saturday": 5,
+    "sunday": 6,
+}
+
+
+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 IntraMapsError("Unexpected response format from IntraMaps")
+
+        fields = extract_panel_fields(response)
+        if not fields:
+            raise SourceArgumentNotFound("address", self._address)
+
+        entries: list[Collection] = []
+
+        # "Bin Day" — weekly general waste, value is a weekday name e.g. "Friday"
+        bin_day = fields.get("Bin Day", "").strip()
+        if bin_day:
+            entries.extend(
+                self._weekly_dates(
+                    bin_day.lower(), "General Waste", ICON_MAP["General Waste"]
+                )
+            )
+
+        # "Recycling Day" — fortnightly, e.g. "Friday Week B; Next: 10 Apr 2026"
+        recycling_day = fields.get("Recycling Day", "").strip()
+        if recycling_day:
+            entries.extend(self._parse_recycling(recycling_day))
+
+        return entries
+
+    @staticmethod
+    def _weekly_dates(
+        day_name: str, waste_type: str, icon: str, count: int = 26
+    ) -> list[Collection]:
+        weekday = WEEKDAYS.get(day_name)
+        if weekday is None:
+            return []
+
+        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(count)
+        ]
+
+    @staticmethod
+    def _parse_recycling(text: str) -> list[Collection]:
+        # Extract "Next: DD Mon YYYY" date
+        match = re.search(r"Next:\s*(\d{1,2}\s+\w+\s+\d{4})", text)
+        if not match:
+            return []
+
+        try:
+            next_date = datetime.strptime(match.group(1), "%d %b %Y").date()
+        except ValueError:
+            return []
+
+        icon = ICON_MAP["Recycling"]
+        return [
+            Collection(
+                date=next_date + timedelta(weeks=i * 2),
+                t="Recycling",
+                icon=icon,
+            )
+            for i in range(13)
+        ]

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

@@ -0,0 +1,99 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Fredrikstad kommune"
+DESCRIPTION = "Source for Fredrikstad kommune waste collection."
+URL = "https://www.fredrikstad.kommune.no"
+TEST_CASES = {
+    "Kanelveien 4": {"address": "Kanelveien 4"},
+}
+
+BASE_URL = "https://arcgis.fredrikstad.kommune.no/server/rest/services/Renovasjon/MinRenovasjon/MapServer"
+SCHEDULE_DAYS = 365
+
+# Static fallback mapping for when the ArcGIS coded value domain does not
+# return proper Norwegian waste type names. Values confirmed by a Fredrikstad
+# resident (GitHub issue #2525).
+WASTE_TYPE_FALLBACK: dict[int, str] = {
+    1: "Restavfall",
+    2: "Papir og plast",
+    4: "Glass og metall",
+    6: "Farlig avfall",
+    16: "Matavfall",
+}
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+
+        waste_types = _get_waste_types(session)
+        avt_lnr = self._get_avt_lnr(session)
+
+        today = datetime.date.today()
+        end_date = today + datetime.timedelta(days=SCHEDULE_DAYS)
+
+        r = session.get(
+            f"{BASE_URL}/1/query",
+            params={
+                "f": "json",
+                "orderByFields": "Dato",
+                "outFields": "Dato,AvfallId",
+                "returnGeometry": "false",
+                "spatialRel": "esriSpatialRelIntersects",
+                "where": (
+                    f"AvtLnr = {avt_lnr} "
+                    f"AND Dato >= date '{today.isoformat()}' "
+                    f"AND Dato <= date '{end_date.isoformat()}'"
+                ),
+            },
+        )
+        r.raise_for_status()
+
+        entries = []
+        for feature in r.json().get("features", []):
+            attr = feature["attributes"]
+            epoch_ms = attr["Dato"]
+            avfall_id = attr["AvfallId"]
+            collection_date = datetime.date.fromtimestamp(epoch_ms / 1000)
+            waste_name = waste_types.get(avfall_id) or WASTE_TYPE_FALLBACK.get(
+                avfall_id, f"Avfall {avfall_id}"
+            )
+            entries.append(Collection(date=collection_date, t=waste_name))
+
+        return entries
+
+    def _get_avt_lnr(self, session: requests.Session) -> int:
+        r = session.get(
+            f"{BASE_URL}/0/query",
+            params={
+                "f": "json",
+                "outFields": "AvtLnr",
+                "returnGeometry": "false",
+                "spatialRel": "esriSpatialRelIntersects",
+                "where": f"UPPER(Adresse) = '{self._address.upper()}' AND AvtStatus = 0",
+            },
+        )
+        r.raise_for_status()
+        features = r.json().get("features", [])
+        if not features:
+            raise SourceArgumentNotFound("address", self._address)
+        return features[0]["attributes"]["AvtLnr"]
+
+
+def _get_waste_types(session: requests.Session) -> dict[int, str]:
+    """Return AvfallId → name mapping from the layer's coded value domain."""
+    r = session.get(f"{BASE_URL}/1", params={"f": "json"})
+    r.raise_for_status()
+    for field in r.json().get("fields", []):
+        if field["name"] == "AvfallId":
+            domain = field.get("domain") or {}
+            if domain.get("type") == "codedValue":
+                return {cv["code"]: cv["name"] for cv in domain["codedValues"]}
+    return {}

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

@@ -0,0 +1,30 @@
+from typing import ClassVar
+
+from waste_collection_schedule import Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.RiSKommunalAT import RiSKommunalSource
+
+TITLE = "Fritzens"
+DESCRIPTION = "Waste collection schedule for the municipality of Fritzens, Austria."
+URL = "https://www.fritzens.gv.at"
+COUNTRY = "at"
+
+TEST_CASES: dict[str, dict] = {"TestSource": {}}
+
+ICON_MAP = {
+    "Biomüll": Icons.ORGANIC,
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Kunststoffmüll": Icons.PLASTIC_PACKAGING,
+    "Sperrmüll": Icons.BULKY,
+}
+
+
+class Source(RiSKommunalSource):
+    BASE_URL = "https://www.fritzens.gv.at"
+    ICON_MAP = ICON_MAP
+    RAISE_ON_EMPTY = True
+    QUERY_PARAMS: ClassVar = {
+        "bdatum": "31.12.9999",
+        "blnr": "",
+        "gnr_search": "0",
+        "menuonr": "219029364",
+    }