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

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

@@ -0,0 +1,65 @@
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Horowhenua District Council"
+DESCRIPTION = "Source for Horowhenua District Council Rubbish & Recycling collection."
+URL = "https://www.horowhenua.govt.nz/"
+TEST_CASES = {
+    "House-Shannon": {
+        "post_code": "4821",
+        "town": "Shannon",
+        "street_name": "Bryce Street",
+        "street_number": "55",
+    },
+    "House-Levin": {
+        "post_code": "5510",
+        "town": "Levin",
+        "street_name": "McKenzie Street",
+        "street_number": "15",
+    },
+    "Commercial-Foxton": {
+        "post_code": "4814",
+        "town": "Foxton",
+        "street_name": "State Highway 1",
+        "street_number": "18",
+    },
+}
+
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+    # Without an explicit Accept header the search endpoint returns XML
+    # instead of JSON.
+    "Accept": "application/json",
+}
+
+ICON_MAP = {
+    "Rubbish": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.horowhenua.govt.nz",
+    argument_name="street_name",
+    headers=HEADERS,
+    warm_up_url="https://www.horowhenua.govt.nz",
+    use_curl_cffi=True,
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(self, post_code: str, town: str, street_name: str, street_number: str):
+        self.post_code = post_code
+        self.town = town.upper()
+        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.town} {self.post_code}"
+        )
+        return self._client.fetch(address=address)

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

@@ -0,0 +1,88 @@
+import logging
+import ssl
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from requests.adapters import HTTPAdapter
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Horsham District Council"
+DESCRIPTION = "Source script for Horsham District Council"
+URL = "https://www.horsham.gov.uk"
+TEST_CASES = {
+    "Blackthorn Avenue - number": {"uprn": 10013792881},
+    "Blackthorn Avenue - string": {"uprn": "10013792881"},
+}
+API_URL = "https://satellite.horsham.gov.uk/environment/refuse/cal_details.asp"
+# Updated 1st April 2026 as Food Waste was added, and the names for the refuse bins had been updated
+ICON_MAP = {
+    "Green Bin for Refuse and Non-Recycling": Icons.GENERAL_WASTE,
+    "Blue-Top Bin for Recycling": Icons.RECYCLING,
+    "Brown-Top Bin for Garden Waste": Icons.GARDEN,
+    "Orange-Top Bin for Food Waste": Icons.BIO_KITCHEN,
+}
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+_LOGGER = logging.getLogger(__name__)
+
+
+class LegacyTLSAdapter(HTTPAdapter):
+    # Modern python libraries reject Horsham server settings and return connection reset errors,
+    # Try and force requests to use downgraded settings
+    def init_poolmanager(self, *args, **kwargs):
+        ctx = ssl.create_default_context()
+        ctx.set_ciphers("AES256-SHA256")  # Explicitly use this cipher
+        ctx.minimum_version = ssl.TLSVersion.TLSv1_2  # Explicitly use this TLS version
+        ctx.maximum_version = ssl.TLSVersion.TLSv1_2  # Explicitly use this TLS version
+        kwargs["ssl_context"] = ctx
+        return super().init_poolmanager(*args, **kwargs)
+
+
+class Source:
+    def __init__(self, uprn: str):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+
+        # Use customised TLS/cipher settings
+        s = requests.Session()
+        s.mount("https://", LegacyTLSAdapter())
+        _LOGGER.warning(
+            "Forcing requests to use legacy TLSv1.2 & AES256-SHA256 to match horsham.gov.uk website"
+        )
+
+        r = s.post(
+            API_URL,
+            data={"uprn": self._uprn},
+        )
+        soup = BeautifulSoup(r.text, features="html.parser")
+        results = soup.find_all("tr")
+
+        entries = []
+        for result in results:
+            result_row = result.find_all("td")
+            if (
+                len(result_row) == 0
+            ):  # This removes the first header row, or any rows with no data
+                continue
+            date = datetime.strptime(
+                result_row[1].text, "%d/%m/%Y"
+            ).date()  # Pull out the rows date
+
+            # The website now uses <li> elements for each bin type
+            list_items = result_row[2].find_all("li")
+            collection_items = [li.get_text(strip=True) for li in list_items]
+            for collection_type in collection_items:
+                if not collection_type:
+                    continue
+                entries.append(
+                    Collection(
+                        date=date,
+                        t=collection_type,
+                        icon=ICON_MAP.get(collection_type),
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,114 @@
+import json
+from datetime import date, datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.AchieveForms import init_session, run_lookup
+
+TITLE = "London Borough of Hounslow"
+DESCRIPTION = "Source for London Borough of Hounslow."
+URL = "https://hounslow.gov.uk"
+TEST_CASES = {
+    "10090801236": {"uprn": 10090801236},
+    "100021552942": {"uprn": 100021552942},
+}
+
+ICON_MAP = {
+    "Residual": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Food": Icons.BIO_KITCHEN,
+    "Garden": Icons.GARDEN,
+}
+
+BASE_URL = "https://my.hounslow.gov.uk"
+INITIAL_URL = f"{BASE_URL}/en/service/Waste_and_recycling_collections"
+AUTH_URL = f"{BASE_URL}/authapi/isauthenticated"
+AUTH_TEST = f"{BASE_URL}/apibroker/domain/my.hounslow.gov.uk"
+API_URL = f"{BASE_URL}/apibroker/runLookup"
+
+TOKEN_LOOKUP_ID = "655f4290810cf"
+JOBS_LOOKUP_ID = "659eb39b66d5a"
+TIMEOUT = 30
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn)
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        sid = init_session(
+            session,
+            INITIAL_URL,
+            AUTH_URL,
+            "my.hounslow.gov.uk",
+            auth_test_url=AUTH_TEST,
+            timeout=TIMEOUT,
+        )
+
+        # Step 1: get Bartec auth token
+        token_resp = run_lookup(
+            session,
+            API_URL,
+            sid,
+            TOKEN_LOOKUP_ID,
+            {"Section 1": {"searchUPRN": {"value": self._uprn}}},
+            timeout=TIMEOUT,
+        )
+        rows = (
+            token_resp.get("integration", {})
+            .get("transformed", {})
+            .get("rows_data", {})
+        )
+        if not rows:
+            raise ValueError(f"Failed to get Bartec token for UPRN {self._uprn}")
+        bartec_token = rows["0"]["bartecToken"]
+
+        # Step 2: get collection jobs for next 6 months
+        today = date.today()
+        six_months = today + timedelta(days=182)
+        jobs_resp = run_lookup(
+            session,
+            API_URL,
+            sid,
+            JOBS_LOOKUP_ID,
+            {
+                "Section 1": {
+                    "searchUPRN": {"value": self._uprn},
+                    "bartecToken": {"value": bartec_token},
+                    "searchFromDate": {"value": today.isoformat()},
+                    "searchToDate": {"value": six_months.isoformat()},
+                }
+            },
+            timeout=TIMEOUT,
+        )
+
+        jobs_rows = (
+            jobs_resp.get("integration", {}).get("transformed", {}).get("rows_data", {})
+        )
+        if not jobs_rows:
+            raise ValueError(f"No collection data found for UPRN {self._uprn}")
+
+        jobs_json = jobs_rows.get("0", {}).get("jobsJSON", "[]")
+        jobs = json.loads(jobs_json.strip())
+
+        seen = set()
+        entries = []
+        for job in jobs:
+            job_date = datetime.strptime(job["jobDate"], "%Y-%m-%d").date()
+            job_type = job.get("jobType", job.get("jobName", "Unknown"))
+            key = (job_date, job_type)
+            if key in seen:
+                continue
+            seen.add(key)
+            entries.append(
+                Collection(
+                    date=job_date,
+                    t=job_type,
+                    icon=ICON_MAP.get(job_type),
+                )
+            )
+
+        if not entries:
+            raise ValueError(f"No collections found for UPRN {self._uprn}")
+        return entries

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

@@ -0,0 +1,72 @@
+from datetime import date
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentException
+
+TITLE = "Hudiksvall"
+DESCRIPTION = "Source for Hudiksvall."
+URL = "https://www.hudiksvall.se"
+TEST_CASES = {
+    "Kommunhuset": {"address": "Trädgårdsgatan 4 Hudiksvall"},
+}
+
+ICON_MAP = {
+    "Restavfall": Icons.GENERAL_WASTE,
+    "Matavfall": Icons.BIO_KITCHEN,
+    "Porslin": Icons.BIO_KITCHEN,
+    "Returpapper": Icons.PAPER,
+    "Pappersförpackningar": Icons.PAPER,
+    "Plastförpackningar": Icons.RECYCLING,
+    "Metallförpackningar": Icons.METAL,
+    "Färgade": Icons.GLASS,
+    "Ofärgade": Icons.GLASS,
+    "Ljuskällor": Icons.ELECTRONICS,
+    "Småbatterier": Icons.BATTERY,
+}
+
+API_URL = "https://gis.hudiksvall.se/origoserver/EDPFuture"
+
+HEADERS = {"User-Agent": "Mozilla/5.0"}
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address: str = address
+
+    def fetch(self) -> list[Collection]:
+        params = {"address": self._address}
+
+        r = requests.get(API_URL, params=params, headers=HEADERS)
+        r.raise_for_status()
+
+        response = r.json()
+        if not response:
+            raise SourceArgumentException(
+                "address",
+                f"No returned building address for: {self._address}",
+            )
+
+        entries = []
+        for container in response:
+            date_ = self.parse_date(
+                container["year"], container["week"], container["day"]
+            )
+            icon = ICON_MAP.get(container["type"])
+            entries.append(Collection(date_, container["type"], icon))
+
+        return entries
+
+    @staticmethod
+    def parse_date(year, week, weekday) -> date:
+        swedish_weekdays = {
+            "Måndag": 1,
+            "Tisdag": 2,
+            "Onsdag": 3,
+            "Torsdag": 4,
+            "Fredag": 5,
+            "Lördag": 6,
+            "Söndag": 7,
+        }
+
+        return date.fromisocalendar(year, week, swedish_weekdays[weekday])

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

@@ -0,0 +1,55 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Hull City Council"
+DESCRIPTION = "Source for Hull City Council."
+URL = "https://hull.gov.uk/"
+TEST_CASES = {
+    "21095794": {"uprn": 21095794},
+    "21009164": {"uprn": "21009164"},
+}
+
+
+ICON_MAP = {
+    "black": Icons.GENERAL_WASTE,
+    "blue": Icons.PAPER,
+    "brown": Icons.BIO_KITCHEN,
+    "bulky": Icons.BULKY,
+}
+
+
+API_URL = "https://www.hull.gov.uk/ajax/bin-collection"
+REFERER = "https://www.hull.gov.uk"
+USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0"
+)
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn: str | int = uprn
+
+    def fetch(self):
+        # get json
+        r = requests.get(
+            API_URL,
+            params={"bindate": self._uprn},
+            headers={"Referer": REFERER, "User-Agent": USER_AGENT},
+        )
+        r.raise_for_status()
+
+        data = r.json()
+        data = data[0] if isinstance(data[0], list) else data
+
+        entries = []
+        for entry in data:
+            date = datetime.strptime(entry["next_collection_date"], "%Y-%m-%d").date()
+            icon = ICON_MAP.get(
+                entry["collection_type"].lower().replace("bin", "").strip()
+            )  # Collection icon
+            type = entry["collection_type"]
+            entries.append(Collection(date=date, t=type, icon=icon))
+
+        return entries

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

@@ -0,0 +1,120 @@
+import re
+from datetime import datetime, timedelta
+
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Hume City Council"
+DESCRIPTION = "Source for hume.vic.gov.au Waste Collection Services"
+URL = "https://hume.vic.gov.au"
+TEST_CASES = {
+    "19 Potter": {
+        "address": "19 Potter Street Craigieburn 3064",
+        "predict": True,
+    },
+    "1/90 Vineyard": {"address": "1/90 Vineyard Road Sunbury, VIC 3429"},  # Wednesday
+    "9-19 McEwen": {"address": "9-19 MCEWEN DRIVE SUNBURY VICTORIA 3429"},  # Wednesday
+    "33 Toyon": {"address": "33 TOYON ROAD KALKALLO  3064"},  # Friday
+}
+
+HEADERS = {
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64; rv:140.0) Gecko/20100101 Firefox/140.0",
+    "accept": "application/json, text/javascript, */*; q=0.01",
+    "Referer": "https://www.hume.vic.gov.au/Residents/Waste/Know-my-bin-day",
+    "Sec-Fetch-Site": "same-origin",
+    "X-Requested-With": "XMLHttpRequest",
+}
+
+ICON_MAP = {
+    "Garbage": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Food and garden": Icons.BIO_KITCHEN,
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.hume.vic.gov.au",
+    argument_name="address",
+    headers=HEADERS,
+    use_curl_cffi=True,
+    impersonate="chrome124",
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(self, address="", predict=False):
+        address = address.strip()
+        address = re.sub(" +", " ", address)
+        address = re.sub(",", "", address)
+        address = re.sub(r"victoria (\d{4})", " \\1", address, flags=re.IGNORECASE)
+        address = re.sub(r" vic (\d{4})", " \\1", address, flags=re.IGNORECASE)
+        self.address = address
+
+        if not isinstance(predict, bool):
+            raise Exception("'predict' must be a boolean value")
+        self.predict = predict
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def collect_dates(self, start_date, weeks):
+        dates = []
+        dates.append(start_date)
+        for _i in range(1, int(4 / weeks)):
+            start_date = start_date + timedelta(days=(weeks * 7))
+            dates.append(start_date)
+        return dates
+
+    def fetch(self) -> list[Collection]:
+        if not self.predict:
+            return self._client.fetch(address=self.address)
+
+        # `predict` needs each block's "note" text (a fortnightly/weekly
+        # hint) that the shared client's parser doesn't return, so fetch
+        # and parse the raw HTML locally for this path.
+        geolocation_id = self._client.resolve_geolocation_id(self.address)
+        html = self._client.get_waste_services_html(geolocation_id)
+        soup = BeautifulSoup(html, "html.parser")
+        services = soup.find_all("div", attrs={"class": "waste-services-result"})
+
+        entries = []
+        for item in services:
+            date_text = item.find("div", attrs={"class": "next-service"})
+            title = item.find("h3")
+            if date_text is None or title is None:
+                continue
+            date_format = "%a %d/%m/%Y"
+            try:
+                cleaned_date_text = (
+                    date_text.text.replace("\r", "").replace("\n", "").strip()
+                )
+                date = datetime.strptime(cleaned_date_text, date_format).date()
+            except ValueError:
+                continue
+
+            waste_type = title.text.strip()
+
+            dates = [date]
+            interval_text = item.find("div", attrs={"class": "note"})
+            if interval_text is not None:
+                if "fortnight" in interval_text.get_text():
+                    weeks = 2
+                elif "same day each week" in interval_text.get_text():
+                    weeks = 1
+                else:
+                    weeks = None
+                if weeks is not None:
+                    dates = self.collect_dates(date, weeks)
+
+            for d in dates:
+                entries.append(
+                    Collection(
+                        date=d,
+                        t=waste_type,
+                        icon=ICON_MAP.get(waste_type, Icons.GENERAL_WASTE),
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,50 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Huntingdonshire District Council"
+DESCRIPTION = (
+    "Source for Huntingdonshire.gov.uk services for Huntingdonshire District Council."
+)
+URL = "https://www.huntingdonshire.gov.uk"
+TEST_CASES = {
+    "Wells Close, Brampton": {"uprn": "100090123510"},
+    "Inkerman Rise, St. Neots": {"uprn": "10000144271"},
+}
+
+ICON_MAP = {
+    "Refuse": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Garden": Icons.GARDEN,
+    "Food": Icons.BIO_KITCHEN,
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = uprn
+
+    def fetch(self):
+        # get json file
+        r = requests.get(
+            f"https://servicelayer3c.azure-api.net/wastecalendar/collection/search/{self._uprn}?authority=HDC&take=20"
+        )
+
+        # extract data from json
+        collections = r.json()["collections"]
+        entries = []
+
+        for collection in collections:
+            for round_type in collection["roundTypes"]:
+                entries.append(
+                    Collection(
+                        date=datetime.strptime(
+                            collection["date"], "%Y-%m-%dT%H:%M:%SZ"
+                        ).date(),
+                        t=round_type.title(),
+                        icon=ICON_MAP.get(round_type),
+                    )
+                )
+
+        return entries