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

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

@@ -0,0 +1,80 @@
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Unley City Council (SA)"
+DESCRIPTION = "Source for Unley City Council rubbish collection."
+URL = "https://www.unley.sa.gov.au/"
+TEST_CASES = {
+    "Test1": {
+        "post_code": "5061",
+        "suburb": "Malvern",
+        "street_name": "Wattle Street",
+        "street_number": "188",
+    },
+    "Test2": {
+        "post_code": 5061,
+        "suburb": "Unley",
+        "street_name": "Unley Road",
+        "street_number": "192",
+    },
+    "Test3": {
+        "post_code": "5063",
+        "suburb": "Parkside",
+        "street_name": "Castle Street",
+        "street_number": 63,
+    },
+}
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0",
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.5",
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "DNT": "1",
+    "Connection": "keep-alive",
+    "Upgrade-Insecure-Requests": "1",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-User": "?1",
+    "Cache-Control": "max-age=0",
+}
+
+ICON_MAP = {
+    "General Waste (Blue Bin)": Icons.GENERAL_WASTE,
+    "Organic Waste (Green or Grey Bin)": Icons.ORGANIC,
+    "Recycling (Yellow Lid Bin)": Icons.RECYCLING,
+    "Residential Street Cleaning": Icons.GENERAL_WASTE,
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Green Waste": Icons.GARDEN,
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.unley.sa.gov.au",
+    argument_name="street_name",
+    search_response_format="xml",
+    headers=HEADERS,
+    use_curl_cffi=True,
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(
+        self, post_code: str, suburb: str, street_name: str, street_number: str | int
+    ):
+        self.post_code = post_code
+        self.suburb = suburb
+        self.street_name = street_name
+        self.street_number = street_number
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def fetch(self) -> list[Collection]:
+        address = (
+            f"{self.street_number} {self.street_name} {self.suburb} SA {self.post_code}"
+        )
+        return self._client.fetch(address=address)

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

@@ -0,0 +1,35 @@
+import logging
+
+# from waste_collection_schedule import Collection
+from .edpevent_se import Source as EdpEventSource
+
+TITLE = "Uppsala Vatten och Avfall AB (Deprecated)"
+DESCRIPTION = "Deprecated, please use edpevent_se instead."
+URL = "https://www.uppsalavatten.se"
+
+# Init logger
+_LOGGER = logging.getLogger(__name__)
+
+TEST_CASES = {
+    "Test1": {
+        "city": "BJÖRKLINGE",
+        "street": "SADELVÄGEN 1",
+    },
+    "Test2": {
+        "city": "BJÖRKLINGE",
+        "street": "BJÖRKLINGE-GRÄNBY 33",
+    },
+    "Test3": {
+        "city": "BJÖRKLINGE",
+        "street": "BJÖRKLINGE-GRÄNBY 20",
+    },
+}
+
+
+class Source(EdpEventSource):
+    def __init__(self, street, city):
+        super().__init__(street, service_provider="uppsalavatten")
+        # Log a warning message indicating that this source is deprecated
+        _LOGGER.warning(
+            "The Uppsala Vatten och Avfall AB source is deprecated, please use edpevent_se instead"
+        )

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

@@ -0,0 +1,97 @@
+import datetime
+import re
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Uttlesford District Council"
+DESCRIPTION = "Source for uttlesford.gov.uk, Uttlesford District Council, UK"
+URL = "https://www.uttlesford.gov.uk"
+TEST_CASES = {
+    "Brook Cottage, CM6 1LW": {"house": "29142-Tuesday"},
+    "Springfields, CM6 1BP": {"house": "26455-Thursday"},
+}
+
+API_URL = "http://bins.uttlesford.gov.uk/collections.php?house={house}"
+
+ICON_MAP = {
+    "black": Icons.GENERAL_WASTE,
+    "green": Icons.RECYCLING,
+    "brown": Icons.BIO_KITCHEN,
+}
+
+PICTURE_MAP = {
+    "black": "https://bins.uttlesford.gov.uk/img/result-black.png",
+    "green": "https://bins.uttlesford.gov.uk/img/result-green.png",
+    "brown": "https://bins.uttlesford.gov.uk/img/result-brown.png",
+}
+
+TEXT_MAP = {
+    "black": "Black (Non-Recyclable)",
+    "green": "Green (Dry Recycling)",
+    "brown": "Brown (Food Waste)",
+}
+
+
+class Source:
+    def __init__(self, house=None):
+        self._house = house
+
+    def fetch(self):
+        q = str(API_URL).format(house=self._house)
+
+        r = requests.get(q)
+        r.raise_for_status()
+
+        def trimsuffix(s):
+            return re.sub(r"(\d)(st|nd|rd|th)", r"\1", s)
+
+        responseContent = r.text
+
+        today = datetime.date.today()
+
+        entries = []
+
+        soup = BeautifulSoup(responseContent, "html.parser")
+        table = soup.findAll("table")
+
+        rows = table[1].findAll(lambda tag: tag.name == "tr")
+
+        for row in rows:
+            fields = row.findChildren()
+            image = row.find("img")
+            datestr = fields[3].text
+            datestr = trimsuffix(datestr) + " " + today.strftime("%Y")
+            date = datetime.datetime.strptime(datestr, "%A %d %B %Y")
+
+            # As they don't show the year we need to check if it should actually be next year
+            if date.date() < today:
+                date = date.replace(year=today.year + 1)
+
+            # As all the image alt text etc is wrong on the website we have to go by the image itself
+            if "green" in image["src"]:
+                collectiontxt = "green"
+            else:
+                collectiontxt = "black"
+
+            entries.append(
+                Collection(
+                    date=date.date(),
+                    t=TEXT_MAP.get(collectiontxt),
+                    picture=PICTURE_MAP.get(collectiontxt),
+                    icon=ICON_MAP.get(collectiontxt),
+                )
+            )
+            # Add a second collection entry as all collections include the brown food bin
+            collectiontxt = "brown"
+            entries.append(
+                Collection(
+                    date=date.date(),
+                    t=TEXT_MAP.get(collectiontxt),
+                    picture=PICTURE_MAP.get(collectiontxt),
+                    icon=ICON_MAP.get(collectiontxt),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,123 @@
+import json
+import random
+from datetime import date, datetime, timedelta
+
+from bs4 import BeautifulSoup
+from curl_cffi import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Vale of Glamorgan Council"
+DESCRIPTION = "Source for Vale of Glamorgan Council."
+URL = "https://valeofglamorgan.gov.uk/"
+TEST_CASES = {
+    "CF62 7JP": {"uprn": 64003486},
+    "CF32 0PW": {"uprn": 64017161},
+}
+
+
+ICON_MAP = {
+    "Trash": Icons.GENERAL_WASTE,
+    "Food": Icons.BIO_KITCHEN,
+    "Garden": Icons.GARDEN,
+    "Paper": Icons.PAPER,
+    "Recycle": Icons.RECYCLING,
+}
+
+WEEKDAYS = [
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+    "Sunday",
+]
+
+API_URL = "https://myvale.valeofglamorgan.gov.uk/getdata.aspx"
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn: str | int = uprn
+
+    def __get_collection(
+        self, session: requests.Session, calendar_url: str, bin_type: str
+    ) -> list[Collection]:
+        r = session.get(calendar_url)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+        entries = []
+        for tr in soup.select("table tr"):
+            tds = tr.select("td")
+            if len(tds) != 2:
+                continue
+
+            months = tds[0].text.strip()
+            days = tds[1].text.strip().replace("and", ",").split(",")
+            for day in days:
+                day = day.strip()
+                if not day.isdigit():
+                    continue
+                dt = datetime.strptime(f"{day} {months}", "%d %B %Y").date()
+                entries.append(Collection(date=dt, t=bin_type, icon=ICON_MAP[bin_type]))
+        return entries
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session(impersonate="chrome")
+
+        timestamp = str(int(datetime.now().timestamp() * 1000))
+        random_callback_number = str(
+            random.randint(10000000000000000000, 99999999999999999999)
+        )
+        params = {
+            "RequestType": "LocalInfo",
+            "ms": "ValeOfGlamorgan/AllMaps",
+            "group": "Waste|new_refuse",
+            "type": "jsonp",
+            "callback": "AddressInfoCallback",
+            "uid": self._uprn,
+            "import": f"jQuery{random_callback_number}_{timestamp}",
+            "_": timestamp,
+        }
+
+        # get json file
+        r = session.get(API_URL, params=params)
+        r.raise_for_status()
+        text = r.text
+        text = text.replace("AddressInfoCallback(", "").rstrip(");")
+        data = json.loads(text)["Results"]["waste"]
+
+        entries: list[Collection] = []
+        recycling_food = data["recycling_food"]
+        if recycling_food not in WEEKDAYS:
+            raise ValueError(f"Unknown recycling_food: {recycling_food}")
+
+        next_recycling_food = date.today()
+        while next_recycling_food.weekday() != WEEKDAYS.index(recycling_food):
+            next_recycling_food += timedelta(days=1)
+
+        entries.extend(
+            Collection(
+                date=next_recycling_food + timedelta(weeks=i),
+                t="Recycling",
+                icon=ICON_MAP["Recycle"],
+            )
+            for i in range(10)
+        )
+        entries.extend(
+            Collection(
+                date=next_recycling_food + timedelta(weeks=i),
+                t="Food",
+                icon=ICON_MAP["Food"],
+            )
+            for i in range(10)
+        )
+
+        entries.extend(
+            self.__get_collection(session, data["residual_calendar_url"], "Trash")
+        )
+        entries.extend(
+            self.__get_collection(session, data["green_calendar_url"], "Garden")
+        )
+
+        return entries

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

@@ -0,0 +1,94 @@
+from datetime import datetime
+
+from curl_cffi import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequiredWithSuggestions,
+)
+
+TITLE = "Valorlux"
+DESCRIPTION = "Source for Valorlux waste collection."
+URL = "https://www.valorlux.lu"
+TEST_CASES = {
+    "Mersch": {"commune": "Mersch"},
+    "Luxembourg City (Tour 1)": {"commune": "Luxembourg", "zone": "Tour 1"},
+    "Parc Hosingen": {"commune": "Parc Hosingen"},
+    "Unknown Commune": {"commune": "Unknown", "zone": None},
+}
+
+API_URL = "https://www.valorlux.lu/api/calendar/all"
+ICON_MAP = {
+    "PMC": Icons.RECYCLING,
+}
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36",
+    "Accept": "application/json, text/plain, */*",
+    "Accept-Language": "en-US,en;q=0.5",
+    "Referer": "https://www.valorlux.lu/",
+    "Origin": "https://www.valorlux.lu",
+}
+
+
+class Source:
+    def __init__(self, commune: str | None = None, zone: str | None = None):
+        self._commune = commune
+        self._zone = zone
+
+    def fetch(self):
+        scraper = requests.Session(impersonate="chrome124")
+        scraper.headers.update(HEADERS)
+        r = scraper.get(API_URL)
+        r.raise_for_status()
+        data = r.json()
+
+        # The API returns two dictionaries of locations, 'cities' and 'otherAddresses'
+        # Merge them into a single dictionary for processing
+        communes = data.get("cities", {})
+        other_communes = data.get("otherAddresses", {})
+        communes.update(other_communes)
+
+        # Step 1: If no commune is provided, raise an exception with a list of all communes
+        if self._commune is None:
+            commune_names = sorted(communes.keys())
+            raise SourceArgumentRequiredWithSuggestions("commune", None, commune_names)
+
+        # Step 2: If commune is provided, check if it's valid
+        if self._commune not in communes:
+            commune_names = sorted(communes.keys())
+            raise SourceArgumentNotFoundWithSuggestions(
+                "commune", self._commune, commune_names
+            )
+
+        # Step 3: Check for zones/tours for the selected commune
+        commune_data = communes[self._commune]
+        zones = list(commune_data.keys())
+
+        # If there are multiple zones and none is selected, raise an exception with the list of zones
+        if len(zones) > 1 and self._zone is None:
+            raise SourceArgumentRequiredWithSuggestions("zone", None, zones)
+
+        # If a zone is selected, check if it's valid
+        if self._zone and self._zone not in zones:
+            raise SourceArgumentNotFoundWithSuggestions("zone", self._zone, zones)
+
+        # Step 4: Fetch the actual collection dates
+        if self._zone:
+            dates = commune_data[self._zone]
+        else:
+            # If there's only one zone, or no zone is needed, take the first one
+            dates = next(iter(commune_data.values()))
+
+        collections = []
+        for date_str in dates:
+            # Use %y for 2-digit year
+            date = datetime.strptime(date_str, "%d/%m/%y").date()
+            collections.append(
+                Collection(
+                    date=date,
+                    t="Valorlux Bag (PMC)",
+                    icon=ICON_MAP.get("PMC"),
+                )
+            )
+
+        return collections

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

@@ -0,0 +1,97 @@
+import re
+from datetime import date, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Värmdö Sophämtning"
+DESCRIPTION = "Source for Värmdö household waste collection."
+URL = "https://www.varmdo.se"
+COUNTRY = "se"
+
+SCHEDULE_URL = "https://www.varmdo.se/byggabomiljo/avfallochatervinning/alltomavfallochatervinning/avfallshamtning/hamtveckoravfallfastlandet.4.4fd26e29194d31bcc1fa6ed.html"
+
+TEST_CASES = {
+    "Rosenmalmsvägen": {"street_address": "Rosenmalmsvägen"},
+    "Abborrberget": {"street_address": "Abborrberget"},
+    "Idskäret": {"street_address": "Idskäret"},
+}
+
+ICON_MAP = {
+    "Trash": Icons.GENERAL_WASTE,
+}
+
+WEEKDAY_MAP = {
+    "måndag": 0,
+    "tisdag": 1,
+    "onsdag": 2,
+    "torsdag": 3,
+    "fredag": 4,
+    "lördag": 5,
+    "söndag": 6,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your street name as shown on the Värmdö kommun waste collection page.",
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street_address": "Street Address",
+    },
+}
+
+
+class Source:
+    def __init__(self, street_address: str):
+        self._street_address = re.sub(r"\d+", "", street_address).strip()
+
+    def fetch(self) -> list[Collection]:
+        response = requests.get(SCHEDULE_URL, timeout=30)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, "html.parser")
+        cell = soup.find("td", string=re.compile(self._street_address, re.I))
+
+        if not cell:
+            raise SourceArgumentNotFound("street_address", self._street_address)
+
+        row = cell.parent
+        weekday_text = row.find_all("td")[1].text.strip().lower()
+
+        if not weekday_text:
+            raise SourceArgumentNotFound("street_address", self._street_address)
+
+        # Determine collection weekday
+        pickup_weekday = 0
+        for name, idx in WEEKDAY_MAP.items():
+            if name in weekday_text:
+                pickup_weekday = idx
+                break
+
+        # Determine even/odd week collection
+        even_weeks = "jämna" in weekday_text
+
+        # Generate upcoming collection dates
+        entries = []
+        current = date.today()
+
+        for _ in range(10):
+            while (
+                current.weekday() != pickup_weekday
+                or (current.isocalendar()[1] % 2 == 0) != even_weeks
+            ):
+                current += timedelta(days=1)
+
+            entries.append(
+                Collection(
+                    date=current,
+                    t="Trash",
+                    icon=ICON_MAP.get("Trash"),
+                )
+            )
+            current += timedelta(days=1)
+
+        return entries

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

@@ -0,0 +1,53 @@
+import json
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+
+TITLE = "VA Syd Sophämntning"
+DESCRIPTION = "Source for VA Syd waste collection."
+URL = "https://www.vasyd.se"
+TEST_CASES = {
+    "Home": {"street_address": "Industrigatan 13, Malmö"},
+    "Polisen": {"street_address": "Drottninggatan 20, Malmö"},
+}
+
+
+class Source:
+    def __init__(self, street_address):
+        self._street_address = street_address
+
+    def fetch(self):
+        data = {"query": self._street_address}
+        response = requests.post(
+            "https://www.vasyd.se/api/sitecore/MyPagesApi/BuildingAddressSearch",
+            data=data,
+        )
+
+        building_data = json.loads(response.text)["items"]
+        building_id = None
+        if building_data and len(building_data) > 0:
+            building_id = building_data[0]["id"]
+
+        if not building_id:
+            return []
+
+        data = {"query": building_id, "street": self._street_address}
+        response = requests.post(
+            "https://www.vasyd.se/api/sitecore/MyPagesApi/WastePickupByAddress",
+            data=data,
+        )
+
+        data = json.loads(response.text)["items"]
+
+        entries = []
+        for item in data:
+            waste_type = item["wasteType"]
+            icon = "mdi:trash-can"
+            if waste_type == "Trädgårdsavfall":
+                icon = "mdi:leaf"
+            next_pickup = item["nextWastePickup"]
+            next_pickup_date = datetime.fromisoformat(next_pickup).date()
+            entries.append(Collection(date=next_pickup_date, t=waste_type, icon=icon))
+
+        return entries