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

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

@@ -0,0 +1,97 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection
+from waste_collection_schedule.exceptions import (
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Reading Council"
+DESCRIPTION = "Source for reading.gov.uk services for Reading Council"
+URL = "https://reading.gov.uk"
+TEST_CASES = {
+    "known_uprn": {"uprn": "310027679"},
+    "known_uprn as number": {"uprn": 310027679},
+    "unknown_uprn_by_number": {"postcode": "RG31 5PN", "housenameornumber": "65"},
+    "unknown_uprn_by_number as number": {
+        "postcode": "RG31 5PN",
+        "housenameornumber": 65,
+    },
+}
+
+ICONS = {
+    "Rubbish": "mdi:trash-can",
+    "Recycling": "mdi:recycle",
+    "Food Waste": "mdi:food",
+    "Garden Waste": "mdi:tree",
+}
+
+COLLECTIONS = {
+    "Domestic Waste Collection Service": "Rubbish",
+    "Recycling Collection Service": "Recycling",
+    "Food Waste Collection Service": "Food Waste",
+    "Garden Waste Collection Service": "Garden Waste",
+}
+
+SEARCH_URLS = {
+    "UPRN": "https://api.reading.gov.uk/rbc/getaddresses",
+    "COLLECTION": "https://api.reading.gov.uk/api/collections",
+}
+
+
+class Source:
+    def __init__(self, uprn=None, postcode=None, housenameornumber=None):
+        self._postcode = postcode
+        self._housenameornumber = str(housenameornumber)
+        self._uprn = uprn
+        if not any((uprn, postcode and housenameornumber)):
+            errors = []
+            if postcode:
+                errors.append("housenameornumber")
+            elif housenameornumber:
+                errors.append("postcode")
+            else:
+                errors = ["uprn", "postcode", "housenameornumber"]
+            raise SourceArgumentExceptionMultiple(
+                errors,
+                "Must provide either a UPRN or both the Postcode and House Name or Number",
+            )
+
+    def fetch(self) -> list[Collection]:
+        if self._uprn is None:
+            self._uprn = self.get_uprn()
+        resp = requests.get(f"{SEARCH_URLS['COLLECTION']}/{self._uprn}")
+        return [self.parse_collection(col) for col in resp.json()["collections"]]
+
+    def get_uprn(self) -> str:
+        resp = requests.get(f"{SEARCH_URLS['UPRN']}/{self._postcode}")
+        addresses = resp.json()["Addresses"]
+        if addresses is None:
+            raise SourceArgumentNotFound("postcode", self._postcode)
+        address = next(filter(self.filter_addresses, addresses), None)
+        if address is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "housenameornumber",
+                self._housenameornumber,
+                {self.extract_nameornum(a) for a in addresses},
+            )
+        return address["AccountSiteUprn"]
+
+    def extract_nameornum(self, address) -> str:
+        nameornum, _ = address["SiteShortAddress"].split(
+            f", {address['SiteAddress2']}, "
+        )
+        return nameornum
+
+    def filter_addresses(self, address) -> bool:
+        nameornum = self.extract_nameornum(address)
+        return self._housenameornumber == nameornum
+
+    def parse_collection(self, col) -> Collection:
+        dt = datetime.strptime(col["date"], "%d/%m/%Y %H:%M:%S").date()
+        waste_type = COLLECTIONS[col["service"]]
+        icon = ICONS[waste_type]
+
+        return Collection(date=dt, t=waste_type, icon=icon)

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

@@ -0,0 +1,116 @@
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Real Luzern"
+DESCRIPTION = "Source script for Real Luzern, Switzerland"
+URL = "https://www.real-luzern.ch"
+
+TEST_CASES = {
+    "Luzern - Heimatweg": {"municipality_id": 13, "street_id": 766},
+    "Luzern - Pliatusblick": {"municipality_id": 13, "street_id": 936},
+    "Emmen": {"municipality_id": 6},
+}
+
+ICON_MAP = {
+    "Kehricht": Icons.GENERAL_WASTE,
+    "Grüngut": Icons.ORGANIC,
+    "Papier": Icons.PAPER,
+    "Karton": Icons.PAPER,
+    "Altmetall": Icons.METAL,
+}
+
+OLD_WASTE_NAME = {  # New fetcher uses different names this should prevent breaking changes
+    "Kehrichtsammlung": "Kehricht",
+    "Grüngutsammlung": "Grüngut",
+    "Papiersammlung": "Papier",
+    "Kartonsammlung": "Karton",
+    "Alteisen/Metallsammlung": "Altmetall",
+}
+
+API_URL = "https://www.real-luzern.ch/abfall/sammeldienst/abfallkalender/"
+
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "municipality_id": "Orts ID",
+        "street_id": "Strassen ID",
+    },
+}
+
+
+class Source:
+    def __init__(self, municipality_id: str | int, street_id: str | int | None = None):
+        self._municipality_id = municipality_id
+        self._street_id = street_id
+        self._ics = ICS()
+        self._ics_params: dict[str, str] | None = None
+
+    def fetch_ics_params(self) -> None:
+        uri = f"{API_URL}?gemid={self._municipality_id}&strid={self._street_id}"
+        r = requests.get(uri)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, features="html.parser")
+        data_div = soup.select_one("div.abfk-calendar.abfk-colors")
+        if not data_div:
+            raise ValueError("No data found")
+
+        tour_id = data_div.get("data-tourid", None)
+        if not tour_id:
+            raise ValueError("No tour id found")
+        categories = data_div.get("data-categories", None)
+        if not categories:
+            raise ValueError("No categories found")
+
+        self._ics_params = {
+            "abfk_calendar_download": "1",
+            "calendar[tourId]": str(tour_id),
+            "calendar[gemeinde]": "Luzern",
+            "calendar[format]": "ics",
+            **{
+                f"calendar[{category}]": category
+                for category in str(categories).split(",")
+            },
+        }
+
+    def fetch(self) -> list[Collection]:
+        fresh = False
+        if not self._ics_params:
+            fresh = True
+            self.fetch_ics_params()
+
+        try:
+            entries = self.get_collections()
+            if not entries:
+                raise ValueError("No entries found")
+            return entries
+        except Exception as e:
+            if fresh:
+                raise e
+            self.fetch_ics_params()
+            return self.get_collections()
+
+    def get_collections(self) -> list[Collection]:
+        if not self._ics_params:
+            raise ValueError("No ics params found")
+
+        r = requests.get(API_URL, params=self._ics_params)
+        r.raise_for_status()
+        data = self._ics.convert(r.text)
+
+        # extract entries
+        entries = []
+
+        for date, waste_type in data:
+            # New fetcher uses different names this should prevent breaking changes
+            waste_type = OLD_WASTE_NAME.get(waste_type, waste_type)
+            entries.append(
+                Collection(
+                    date=date,
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,141 @@
+import logging
+from datetime import datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Recycle!"
+DESCRIPTION = "Source for RecycleApp.be"
+URL = "https://www.recycleapp.be"
+TEST_CASES = {
+    "1140 Evere, Bazellaan 1": {
+        "postcode": 1140,
+        "street": "Bazellaan",
+        "house_number": 1,
+    },
+    "3001, Waversebaan 276 with events": {
+        "postcode": 3001,
+        "street": "Waversebaan",
+        "house_number": 276,
+    },
+    "3001, Waversebaan 276 without events": {
+        "postcode": 3001,
+        "street": "Waversebaan",
+        "house_number": 276,
+        "add_events": False,
+    },
+    "1400, Rue de namur 1 with events": {
+        "postcode": 1400,
+        "street": "Rue de namur",
+        "house_number": 1,
+        "add_events": True,
+    },
+    "3200 Th. De Beckerstraat 1": {
+        "postcode": 3200,
+        "street": "Th. De Beckerstraat",
+        "house_number": 1,
+    },
+    "9180 Lokeren, Abelendreef 1": {
+        "postcode": 9180,
+        "street": "Abelendreef",
+        "house_number": 1,
+    },
+    "8700 Abeelstraat 1": {
+        "postcode": 8700,
+        "street": "Abeelstraat",
+        "house_number": 1,
+    },
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Source:
+    def __init__(self, postcode, street, house_number, add_events=True):
+        self._postcode = postcode
+        # Steet search does not work with . in the street name and with the chars in front of the .
+        self._street = street
+        self._steet_search = street.split(".")[-1]
+        self._house_number = house_number
+        self._add_events = add_events
+
+    def fetch(self):
+        url = "https://api.fostplus.be/recyclecms/public/v1"
+        headers = {
+            "x-consumer": "recycleapp.be",
+            "User-Agent": "",
+        }
+
+        params = {"q": self._postcode}
+        r = requests.get(f"{url}/zipcodes", params=params, headers=headers)
+        r.raise_for_status()
+        items = r.json()["items"]
+        if len(items) == 0:
+            raise SourceArgumentNotFound("postcode", self._postcode)
+
+        for item in items:
+            error = None
+            if not item["available"]:
+                continue
+            zipcodeId = item["id"]
+            try:
+                entries = self._fetch_zipcode(zipcodeId, url, headers)
+                if entries:
+                    return entries
+            except SourceArgumentNotFound as e:
+                error = e
+
+        if error:
+            raise error
+        raise Exception(
+            "No data found for the postcode"
+            + (", tired multiple zipcode, entries" if len(items) > 1 else "")
+        )
+
+    def _fetch_zipcode(
+        self, zipcodeId: str, url: str, headers: dict[str, str]
+    ) -> list[Collection]:
+        params = {"q": self._steet_search, "zipcodes": zipcodeId}
+        r = requests.post(f"{url}/streets", params=params, headers=headers)
+        r.raise_for_status()
+
+        streetId = None
+        items = r.json()["items"]
+        if len(items) == 0:
+            raise SourceArgumentNotFound("street", self._street)
+        for item in items:
+            if item["name"].lower().strip() == self._street.lower().strip():
+                streetId = item["id"]
+        if streetId is None:
+            _LOGGER.warning(
+                f"No exact street match found, using first result: {r.json()['items'][0]['name']}"
+            )
+            streetId = items[0]["id"]
+
+        now = datetime.now()
+        fromDate = now.strftime("%Y-%m-%d")
+        untilDate = (now + timedelta(days=365)).strftime("%Y-%m-%d")
+        params = {
+            "zipcodeId": zipcodeId,
+            "streetId": streetId,
+            "houseNumber": self._house_number,
+            "fromDate": fromDate,
+            "untilDate": untilDate,
+            #            "size":100,
+        }
+        r = requests.get(f"{url}/collections", params=params, headers=headers)
+        r.raise_for_status()
+
+        entries = []
+        for item in r.json()["items"]:
+            if "exception" in item and "replacedBy" in item["exception"]:
+                continue
+
+            date = datetime.strptime(item["timestamp"], "%Y-%m-%dT%H:%M:%S.000Z").date()
+            if item["type"] == "collection":
+                entries.append(Collection(date, item["fraction"]["name"]["en"]))
+            elif item["type"] == "event" and self._add_events:
+                entries.append(Collection(date, item["event"]["title"]["en"]))
+
+        return entries