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

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

@@ -0,0 +1,316 @@
+import logging
+from datetime import datetime
+from typing import Literal
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequiredWithSuggestions,
+)
+
+TITLE = "Sammelkalender.ch"
+DESCRIPTION = "Source for Sammelkalender.ch."
+URL = "https://info.sammelkalender.ch"
+TEST_CASES = {
+    "zeba Baar Aberenrain 10": {
+        "service_provider": "zeba",
+        "municipality": "Baar",
+        "street": "Aberenrain",
+        "hnr": 10,
+    },
+    "zkri Rothenthurm": {
+        "service_provider": "zkri",
+        "municipality": "Rothenthurm",
+    },
+    "ZKRI, Schwyz Seewen": {
+        "service_provider": "zkri",
+        "municipality": "Schwyz",
+        "street": "Seewen",
+    },
+    "Real Luzern, Meggen": {
+        "service_provider": "real_luzern",
+        "municipality": "Meggen",
+    },
+    "Real Luzern, Malters, Bodenmättli": {
+        "service_provider": "real_luzern",
+        "municipality": "Malters",
+        "street": "Bodenmättli",
+    },
+    "Zaku Altdorf dag": {
+        "service_provider": "zaku",
+        "municipality": "Altdorf",
+        "street": "dag",
+    },
+}
+
+
+ICON_MAP = {
+    "Kehricht": Icons.GENERAL_WASTE,
+    "Christbaum": Icons.CHRISTMAS_TREE,
+    "Grüngut": Icons.ORGANIC,
+    "Karton": Icons.PAPER,
+    "Papier": Icons.PAPER,
+    "Alteisen/Metall": Icons.METAL,
+}
+
+SERVICES = {
+    "zeba": {
+        "title": "Zeba",
+        "url": "https://www.zebazug.ch",
+        "api_url_search": "https://www.zeba.sammelkalender.ch/kunden_WANN_auswahl_form.php",
+        "api_url_bin": "https://www.zeba.sammelkalender.ch/kunden_sammlung_ausw_cont.php",
+    },
+    "zkri": {
+        "title": "ZKRI",
+        "url": "https://zkri.ch",
+        "api_url_search": "https://daten.zkri.ch/web/Sammelkalender/kunden_WANN_auswahl_form.php",
+        "api_url_bin": "https://daten.zkri.ch/web/Sammelkalender/kunden_sammlung_ausw_cont.php",
+    },
+    "real_luzern": {
+        "title": "Real Luzern",
+        "url": "https://www.realluzern.ch",
+        "api_url_search": "https://www.real.sammelkalender.ch/app/appSelect.php",
+        "api_url_bin": "https://www.real.sammelkalender.ch/app/appSammeldaten.php",
+    },
+    "zaku": {
+        "title": "ZAKU Entsorgung",
+        "url": "https://www.zaku.ch",
+        "api_url_search": "https://www.zaku.sammelkalender.ch/appSelect.php",
+        "api_url_bin": "https://www.zaku.sammelkalender.ch/appSammeldaten.php",
+    },
+}
+
+EXTRA_INFO = [
+    {
+        "title": s["title"],
+        "url": s["url"],
+        "default_params": {
+            "service_provider": key,
+        },
+    }
+    for key, s in SERVICES.items()
+]
+
+
+PROVIDER_LITERALS = Literal["zeba", "zkri", "real_luzern", "zaku"]
+
+
+API_URL = ""
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Source:
+    def __init__(
+        self,
+        service_provider: PROVIDER_LITERALS,
+        municipality: str,
+        street: str | None = None,
+        hnr: str | int | None = None,
+    ) -> None:
+        service_provider_str = service_provider.lower()
+        if service_provider not in SERVICES:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "service_provider", service_provider, list(SERVICES.keys())
+            )
+        self._search_url = SERVICES[service_provider_str]["api_url_search"]
+        self._bin_url = SERVICES[service_provider_str]["api_url_bin"]
+
+        self._municipality: str = municipality
+        self._street: str | None = street
+        self._hnr: str | None = str(hnr) if hnr is not None else None
+
+        self._municipality_id: str | None = None
+        self._address_id: str | None = None
+
+    @staticmethod
+    def _compare(s1: str, s2: str | list[str]) -> bool:
+        if isinstance(s2, str):
+            s2 = [s2]
+
+        for s in s2:
+            if s1.lower().replace(" ", "").replace("str.", "straße").replace(
+                "strasse", "straße"
+            ) == s.lower().replace(" ", "").replace("str.", "straße").replace(
+                "strasse", "straße"
+            ):
+                return True
+        return False
+
+    def _get_streets(self, sage: bool = False) -> list[dict]:
+        params: dict[str, str | int | None] = {
+            "optGem": self._municipality_id,
+            "Jahr": None,
+        }
+        if sage:
+            params["fuerSage"] = 1
+        else:
+            params["fuerStr"] = 1
+
+        r = requests.get(self._search_url, params=params)
+        r.raise_for_status()
+        streets = r.json()
+
+        if len(streets) == 0:
+            return []
+        return streets
+
+    def _fetch_sage(self) -> None:
+        sages = self._get_streets(sage=True)
+        if not sages:
+            return
+        # check: only one sage exists?
+        if len(sages) == 1:
+            self._address_id = sages[0]["SAGEid"]
+            return
+        # check: street parameter defined?
+        if not self._street:
+            sage_names = list({s.get("STRname") or s.get("SAGEname") for s in sages})
+            # by default use first Sammelgebiet and log a Warning
+            # (prevents breaking changes: existing users may have no street configured, because it was not mandatory previously)
+            self._address_id = sages[0]["SAGEid"]
+            _LOGGER.warning(
+                "No Sammelgebiet configured for this municipality. Using default Sammelgebiet '%s'. To configure, insert for the parameter 'street': %s",
+                sages[0]["SAGEname"],
+                ", ".join(sage_names),
+            )
+            return
+        # otherwise find correct sage
+        for sage in sages:
+            if self._compare(self._street, [sage["SAGEabk"], sage["SAGEname"]]):
+                self._address_id = sage["SAGEid"]
+                return
+        if self._address_id is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street",
+                self._street,
+                list({s["SAGEname"] for s in sages}),
+            )
+
+    def _fetch_street(self) -> None:
+        streets = self._get_streets()
+
+        # switch to Sammelgebiete if API either returns no streets or one dummy street
+        if not streets or (
+            len(streets) == 1
+            and streets[0].get("STRname") is None
+            and streets[0].get("SAGEid") is not None
+        ):
+            self._fetch_sage()
+            return
+
+        self._address_id = None
+        street_matches = []
+        if len(streets) == 1:
+            street_matches = streets
+        else:
+            if not self._street:
+                street_names = list(
+                    {s.get("STRname") or s.get("SAGEname") for s in streets}
+                )
+                raise SourceArgumentRequiredWithSuggestions(
+                    "street", "Street required for this municipality", street_names
+                )
+            for street in streets:
+                if self._compare(street["STRname"], self._street):
+                    street_matches.append(street)
+
+        if not street_matches:
+            raise ValueError(
+                f"Invalid street: {self._street}, use one of {list({s['STRname'] for s in streets})}"
+            )
+
+        for street in street_matches:
+            if not street["STRhausnr"]:
+                self._address_id = street["SAGEid"]
+                break
+
+            if self._hnr is None:
+                raise SourceArgumentRequiredWithSuggestions(
+                    "hnr",
+                    "House number required for this street",
+                    [s["STRhausnr"] for s in street_matches],
+                )
+            if self._compare(street["STRhausnr"], self._hnr):
+                self._address_id = street["SAGEid"]
+                break
+
+        if not self._address_id:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "hnr",
+                self._hnr,
+                list({s["STRhausnr"] for s in street_matches}),
+            )
+
+    def _fetch_ids(self) -> None:
+        params = {
+            "optGem": "GEM",
+            "Jahr": None,
+        }
+
+        # get json file
+        r = requests.get(self._search_url, params=params)
+        r.raise_for_status()
+        self._municipality_id = None
+        for mun in r.json():
+            if self._compare(mun["GEMname"], self._municipality):
+                self._municipality_id = mun["GEMid"]
+                break
+        if not self._municipality_id:
+            raise ValueError(
+                f"Invalid municipality: {self._municipality}, use one of {[m['GEMname'] for m in r.json()]}"
+            )
+
+        self._fetch_street()
+
+    def fetch(self) -> list[Collection]:
+        fresh_ids = False
+        if self._municipality_id is None:
+            fresh_ids = True
+            self._fetch_ids()
+        try:
+            return self._get_collections()
+        except Exception:
+            if fresh_ids:
+                raise
+            self._fetch_ids()
+            return self._get_collections()
+
+    def _get_collections(self) -> list[Collection]:
+        today = datetime.now()
+        year = today.year
+        entries = self._get_collections_year(year)
+        if today.month == 12:
+            try:
+                entries += self._get_collections_year(year + 1)
+            except Exception:
+                pass
+        return entries
+
+    def _get_collections_year(self, year: int) -> list[Collection]:
+        if self._municipality is None:
+            raise ValueError("Municipality required")
+
+        params: dict[str, str | int | None] = {
+            "nGem": self._municipality_id,
+            "nAbar": "null",
+            "nSage": self._address_id,
+            "sDatum": "",
+            "delsel": "no",
+            "jahr1": year,
+        }
+        r = requests.get(self._bin_url, params=params)
+        r.raise_for_status()
+
+        entries = []
+        for d in r.json():
+            date = datetime.strptime(d["DATUM"], "%Y-%m-%d").date()
+            bin_types = d["AbarOne"]
+            if bin_types is None:
+                continue
+            for bin_type in bin_types.split("-"):
+                icon = ICON_MAP.get(bin_type)  # Collection icon
+                entries.append(Collection(date=date, t=bin_type, icon=icon))
+
+        return entries

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

@@ -0,0 +1,175 @@
+from datetime import date, datetime, timedelta
+from urllib.parse import quote
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentRequired,
+)
+
+TITLE = "City of San Antonio"
+DESCRIPTION = "Source for City of San Antonio, Texas waste collection."
+URL = "https://www.sa.gov/Directory/Departments/SWMD/Garbage/My-Collection-Day"
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "The source argument is the street number and street name to the house with waste collection. The address can be tested [here](https://www.sa.gov/Directory/Departments/SWMD/Brush-Bulky/My-Collection-Day).",
+}
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street number and street name (e.g., 123 Main St)",
+    }
+}
+
+API_URL = "https://gis.sanantonio.gov/swmd/mycollectionday/Request.aspx?addr={addr}"
+COUNTRY = "us"
+TEST_CASES = {
+    "H-E-B Corporate Office Headquarters": {"address": "646 S Flores St"},
+    "Freeman Coliseum": {"address": "3201 E Houston St"},
+    "Witte Museum": {"address": "3801 Broadway"},
+}
+
+ICON_MAP = {
+    "Garbage": Icons.GENERAL_WASTE,
+    "Recycle": Icons.RECYCLING,
+    "Organics": Icons.ORGANIC,
+    "Brush": Icons.GARDEN,
+    "Bulky": Icons.BULKY,
+}
+
+DAY_OF_WEEK = {
+    "MONDAY": 0,
+    "TUESDAY": 1,
+    "WEDNESDAY": 2,
+    "THURSDAY": 3,
+    "FRIDAY": 4,
+    "SATURDAY": 5,
+    "SUNDAY": 6,
+}
+
+
+def _get_thanksgiving(year: int) -> date:
+    nov_first = date(year, 11, 1)
+    days_until_thursday = (3 - nov_first.weekday()) % 7
+    first_thursday = nov_first + timedelta(days=days_until_thursday)
+    return first_thursday + timedelta(weeks=3)
+
+
+def _get_mlk_day(year: int) -> date:
+    jan_first = date(year, 1, 1)
+    days_until_monday = (0 - jan_first.weekday()) % 7
+    first_monday = jan_first + timedelta(days=days_until_monday)
+    return first_monday + timedelta(weeks=2)
+
+
+def _get_shifting_holidays(year: int) -> list[date]:
+    return [
+        _get_thanksgiving(year),
+        date(year, 12, 25),
+        date(year, 1, 1),
+        _get_mlk_day(year),
+    ]
+
+
+def _get_week_bounds(d: date) -> tuple[date, date]:
+    days_since_sunday = (d.weekday() + 1) % 7
+    week_start = d - timedelta(days=days_since_sunday)
+    week_end = week_start + timedelta(days=6)
+    return week_start, week_end
+
+
+def _adjust_for_holidays(collection_date: date) -> date:
+    collection_dow = collection_date.weekday()
+
+    if collection_dow > 4:
+        return collection_date
+
+    for year in range(collection_date.year - 1, collection_date.year + 2):
+        for holiday in _get_shifting_holidays(year):
+            week_start, week_end = _get_week_bounds(holiday)
+
+            if week_start <= collection_date <= week_end:
+                if collection_dow >= holiday.weekday():
+                    return collection_date + timedelta(days=1)
+
+    return collection_date
+
+
+def _get_next_day_of_week(day_name: str, *, weeks: int = 4) -> list[date]:
+    day_name = day_name.upper().strip()
+    if day_name not in DAY_OF_WEEK:
+        return []
+
+    target_weekday = DAY_OF_WEEK[day_name]
+    today = date.today()
+    days_ahead = target_weekday - today.weekday()
+    if days_ahead < 0:
+        days_ahead += 7
+
+    first_date = today + timedelta(days=days_ahead)
+    dates = [first_date + timedelta(weeks=i) for i in range(weeks)]
+
+    return [_adjust_for_holidays(d) for d in dates]
+
+
+def _parse_week_of_date(date_str: str) -> date | None:
+    if not date_str or not date_str.startswith("Week of "):
+        return None
+    date_part = date_str.replace("Week of ", "").strip()
+    return datetime.strptime(date_part, "%m/%d/%Y").date()
+
+
+class Source:
+    def __init__(self, address: str):
+        if address is None or address.strip() == "":
+            raise SourceArgumentRequired("address", "Address is required")
+        self._address: str = address
+
+    def fetch(self) -> list[Collection]:
+        r = requests.get(
+            API_URL.format(addr=quote(self._address)),
+            timeout=30,
+        )
+        r.raise_for_status()
+        data = r.json()
+        if data == []:
+            raise ValueError("Address not found")
+
+        entries: list[Collection] = []
+
+        if not data:
+            return entries
+
+        attributes = data[0].get("attributes", {})
+        no_service = True
+        for waste_type in ("Garbage", "Recycle", "Organics"):
+            day_name = attributes.get(waste_type)
+            no_svc = day_name == "NO SERVICE"
+            no_service &= no_svc
+            if not day_name or no_svc:
+                continue
+
+            if waste_type == "Organics" and not attributes.get("isQualifyOrganics"):
+                continue
+
+            for collection_date in _get_next_day_of_week(day_name):
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t=waste_type,
+                        icon=ICON_MAP.get(waste_type),
+                    )
+                )
+
+        for waste_type in ("Brush", "Bulky"):
+            date_str = attributes.get(waste_type)
+            parsed_date = _parse_week_of_date(date_str)
+            if parsed_date:
+                entries.append(
+                    Collection(
+                        date=parsed_date,
+                        t=waste_type,
+                        icon=ICON_MAP.get(waste_type, "mdi:trash-can-outline"),
+                    )
+                )
+        if no_service and not entries:
+            raise ValueError(f"No waste collection service found for {self._address}")
+        return entries

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

@@ -0,0 +1,62 @@
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "City of San Diego"
+DESCRIPTION = "Source for the City of San Diego."
+URL = "https://www.sandiego.gov/"
+COUNTRY = "us"
+TEST_CASES = {
+    "Test_001": {"id": "a4Ot0000000fEYZEA2"},
+    "Test_002": {"id": "a4Ot0000001EEsyEAG"},
+    "Test_003": {"id": "a4Ot0000000eANbEAM"},
+}
+ICON_MAP = {
+    "Trash": Icons.GENERAL_WASTE,
+    "Organics": Icons.ORGANIC,
+    "Recyclables": Icons.RECYCLING,
+}
+HOW_TO_GET_ARGUMENTS_DESCRIPTION: dict = {
+    "en": "The id can be found by visiting https://getitdone.sandiego.gov/apex/CollectionMapLookup) and searching for your address. Click on the Bookmarkable Page` button and when the Schedule Detail page has loaded you can see the id in the url.",
+}
+PARAM_TRANSLATIONS: dict = {
+    "en": {
+        "id": "The unique identifier for your properties collection schedule",
+    }
+}
+PARAM_DESCRIPTIONS: dict = {
+    "en": {
+        "id": "The unique identifier for your properties collection schedule",
+    }
+}
+
+
+class Source:
+    def __init__(self, id: str):
+        self._id: str = id
+
+    def fetch(self):
+        s = requests.Session()
+
+        r = s.get(f"https://getitdone.sandiego.gov/CollectionDetail?id={self._id}")
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.content, "html.parser")
+        columns = soup.find_all("div", {"class": "four columns"})
+
+        entries = []
+        for item in columns[1:]:
+            waste_type = item.find("h3").text
+            waste_date = re.search(r"(\d+/\d+/\d+)", item.text)
+            entries.append(
+                Collection(
+                    date=datetime.strptime(waste_date.group(1), "%m/%d/%Y").date(),
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,81 @@
+# nearly identical to stavanger_no
+
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Sandnes Kommune"
+DESCRIPTION = "Source for Sandnes Kommune, Norway"
+URL = "https://www.sandnes.kommune.no/"
+TEST_CASES = {
+    "TestcaseI": {
+        "id": "181e5aac-3c88-4b0b-ad46-3bd246c2be2c",
+        "municipality": "Sandnes kommune 2020",
+        "gnumber": "62",
+        "bnumber": "281",
+        "snumber": "0",
+    },
+    "TestcaseII": {
+        "id": "cb263140-1743-4459-ab3a-a9677884904f",
+        "municipality": "Sandnes kommune 2020",
+        "gnumber": 33,
+        "bnumber": 844,
+        "snumber": 0,
+    },
+}
+
+ICON_MAP = {
+    "Restavfall": Icons.GENERAL_WASTE,
+    "Papp/papir": Icons.PAPER,
+    "Papir": Icons.PAPER,
+    "Bio": Icons.ORGANIC,
+    "Våtorganisk avfall": Icons.ORGANIC,
+    "Juletre": Icons.CHRISTMAS_TREE,
+}
+
+
+class Source:
+    def __init__(self, id, municipality, gnumber, bnumber, snumber):
+        self._id = id
+        self._municipality = municipality
+        self._gnumber = gnumber
+        self._bnumber = bnumber
+        self._snumber = snumber
+
+    def fetch(self):
+        url = "https://www.hentavfall.no/rogaland/sandnes/tommekalender/show"
+
+        params = {
+            "id": self._id,
+            "municipality": self._municipality,
+            "gnumber": self._gnumber,
+            "bnumber": self._bnumber,
+            "snumber": self._snumber,
+        }
+
+        r = requests.get(url, params=params)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        tag = soup.find_all("option")
+        year = tag[0].get("value").split("-")
+        year = year[1]
+
+        entries = []
+        for tag in soup.find_all("tr", {"class": "waste-calendar__item"}):
+            if tag.text.strip() == "Dato og dag\nAvfallstype":
+                continue
+
+            date = tag.text.strip().split(" - ")
+            date = datetime.strptime(date[0] + "." + year, "%d.%m.%Y").date()
+
+            for img in tag.find_all("img"):
+                waste_type = img.get("title")
+                entries.append(
+                    Collection(date, waste_type, icon=ICON_MAP.get(waste_type))
+                )
+
+        return entries