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

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

@@ -0,0 +1,97 @@
+from datetime import date, 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.ArcGis import (
+    ArcGisError,
+    geocode,
+    get_next_n_dates,
+    query_feature_layer,
+)
+
+TITLE = "Charleston County, SC"
+DESCRIPTION = "Source for Charleston County, SC residential curbside recycling."
+URL = (
+    "https://www.charlestoncounty.org/departments/environmental-management/recycle.php"
+)
+COUNTRY = "us"
+
+TEST_CASES = {
+    "Downtown Charleston": {"address": "123 Coming St, Charleston, SC 29403"},
+    "Johns Island": {"address": "2758 August Rd, Johns Island, SC 29455"},
+}
+
+SOURCE_CODEOWNERS = ["@dmkjr"]
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Full street address including city, state, and ZIP code.",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+FEATURE_URL = "https://services.arcgis.com/jR9eNCjAkxwH2nLe/arcgis/rest/services/Curbside_Recycling_Days/FeatureServer/0"
+DATE_FORMAT = "%B %d"
+
+# The county publishes only the next exact pickup date; recycling then
+# recurs on a fixed biweekly cadence, so project that many further pickups.
+PICKUPS_AHEAD = 13
+
+
+def _parse_next_pickup(value: str) -> date:
+    """Parse the yearless next-pickup date published by Charleston County."""
+    today = date.today()
+    parsed = datetime.strptime(value.strip(), DATE_FORMAT).date()
+    pickup = parsed.replace(year=today.year)
+
+    # A January pickup published in December belongs to the next calendar year.
+    if pickup < today and (today - pickup).days > 30:
+        pickup = pickup.replace(year=today.year + 1)
+
+    # The layer is normally updated before each collection. If it is briefly
+    # stale after a pickup, retain its official biweekly cadence.
+    while pickup < today:
+        pickup += timedelta(weeks=2)
+
+    return pickup
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        try:
+            location = geocode(self._address)
+            features = query_feature_layer(
+                FEATURE_URL,
+                geometry=location,
+                out_fields="PickupDate",
+            )
+        except ArcGisError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        pickup_date = (features[0].get("PickupDate") or "").strip()
+        if not pickup_date:
+            raise SourceArgumentNotFound("address", self._address)
+
+        try:
+            next_pickup = _parse_next_pickup(pickup_date)
+        except ValueError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        return [
+            Collection(
+                date=pickup,
+                t="Recycling",
+                icon=Icons.RECYCLING,
+            )
+            for pickup in get_next_n_dates(
+                next_pickup, PICKUPS_AHEAD, timedelta(weeks=2)
+            )
+        ]

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

@@ -0,0 +1,116 @@
+from datetime import date, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+from dateutil.parser import parse
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Charnwood"
+DESCRIPTION = "Source for Charnwood."
+URL = "https://www.charnwood.gov.uk/"
+TEST_CASES = {
+    "111, Main Street, Swithland": {"address": "111, Main Street, Swithland"},
+    "2, The Banks, Sileby": {"address": "2 The Banks, Sileby"},
+}
+
+
+ICON_MAP = {
+    "Refuse": Icons.GENERAL_WASTE,
+    "Garden Waste": Icons.GARDEN,
+    "Recycling": Icons.RECYCLING,
+}
+
+
+API_URL = "https://my.charnwood.gov.uk/my-property-finder"
+SEARCH_URL = "https://my.charnwood.gov.uk/data/ac/addresses.json"
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address_search: str = address
+        self._address_compare: str = address.lower().replace(" ", "").replace(",", "")
+        self._address_id = None
+
+    def _match_address(self, address: str) -> bool:
+        return (
+            address.lower().replace(" ", "").replace(",", "") == self._address_compare
+        )
+
+    @staticmethod
+    def _parse_date(date_str: str) -> date:
+        if date_str.lower() == "today":
+            return date.today()
+
+        if date_str.lower() == "tomorrow":
+            return date.today() + timedelta(days=1)
+
+        return parse(date_str).date()
+
+    def _get_address_id(self):
+        params = {
+            "term": self._address_search,
+        }
+        r = requests.get(SEARCH_URL, params=params)
+        r.raise_for_status()
+        data = r.json()
+        if not data:
+            raise SourceArgumentNotFound(
+                "address",
+                self._address_search,
+            )
+
+        for address in data:
+            if self._match_address(address["label"]):
+                self._address_id = address["value"]
+                return
+        raise SourceArgumentNotFoundWithSuggestions(
+            "address", self._address_search, [address["label"] for address in data]
+        )
+
+    def fetch(self) -> list[Collection]:
+        fresh_id = False
+        if not self._address_id:
+            self._get_address_id()
+            fresh_id = True
+
+        try:
+            return self._get_collections()
+        except Exception:
+            if fresh_id:
+                raise
+            self._get_address_id()
+            return self._get_collections()
+
+    def _get_collections(self) -> list[Collection]:
+        if not self._address_id:
+            raise ValueError("Address not set")
+
+        args = {"address_id": self._address_id}
+
+        # get json file
+        r = requests.get(API_URL, params=args)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        collection_panel = soup.find("div", {"class": "refusecollectiondates"})
+        if not collection_panel:
+            raise ValueError("No collection panel found")
+        entries = []
+
+        for li in collection_panel.select("li"):
+            date_tag = li.find("strong")
+            if not date_tag:
+                continue
+            date_str = date_tag.text.strip()
+            waste_type_tag = date_tag.find_next("a")
+            if not waste_type_tag:
+                continue
+            waste_type = waste_type_tag.text.strip()
+            date_ = self._parse_date(date_str)
+            entries.append(Collection(date_, waste_type, icon=ICON_MAP.get(waste_type)))
+
+        return entries

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

@@ -0,0 +1,85 @@
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Chelmsford City Council"
+DESCRIPTION = "Source for Chelmsford City Council, UK"
+URL = "https://www.chelmsford.gov.uk/"
+COUNTRY = "uk"
+TEST_CASES = {
+    "Test_001": {"collection_round": "Tuesday A"},
+    "Test_002": {"collection_round": "Thursday B"},
+}
+
+ICON_MAP = {
+    "food waste": Icons.BIO_KITCHEN,
+    "black bin": Icons.GENERAL_WASTE,
+    "brown bin": Icons.BIO_KITCHEN,
+    "green box": Icons.GLASS,
+    "paper sack": Icons.PAPER,
+    "card sack": Icons.PAPER,
+    "plastic and cartons bag": Icons.PLASTIC_PACKAGING,
+}
+
+# ### Arguments affecting the configuration GUI ####
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {  # Optional dictionary to describe how to get the arguments, will be shown in the GUI configuration form above the input fields, does not need to be translated in all languages
+    "en": "You can find your collection round by visiting https://www.chelmsford.gov.uk/bins-and-recycling/check-your-collection-day and entering in your address details.",
+}
+
+PARAM_DESCRIPTIONS = {  # Optional dict to describe the arguments, will be shown in the GUI configuration below the respective input field
+    "en": {
+        "collection_round": "Collection round identifier (e.g. Tuesday A). You can find yours by going to https://www.chelmsford.gov.uk/bins-and-recycling/check-your-collection-day and entering in your address details.",
+    },
+}
+
+
+class Source:
+    def __init__(self, collection_round):
+        self._collection_round = collection_round
+
+    def fetch(self) -> list[Collection]:
+        url = f"https://www.chelmsford.gov.uk/bins-and-recycling/check-your-collection-day/{self._collection_round.lower().replace(' ', '-')}-collection-calendar/"
+
+        r = requests.get(url)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.content, "html.parser")
+
+        divs = soup.find_all("div", class_="textcontent")
+
+        entries = []
+
+        for div in divs:
+            heading_items = div.find_all(["h2"])
+            list_items = div.find_all(["ul", "ol"])
+
+            for list in list_items:
+                items = list.find_all("li")
+                for item in items:
+                    it = item.get_text(strip=True)
+                    date_str, items = it.split(":")
+                    _day, date, month = date_str.split()
+
+                    year = None
+                    for h in heading_items:
+                        heading = h.get_text(strip=True)
+                        if month in heading:
+                            year = heading.split()[1]
+                            break
+
+                    date = datetime.strptime(
+                        f"{date} {month} {year}", "%d %B %Y"
+                    ).date()
+                    for i in items.split(","):
+                        waste_type = i.strip()
+                        entries.append(
+                            Collection(
+                                date=date,
+                                t=waste_type.title(),
+                                icon=ICON_MAP.get(waste_type),
+                            )
+                        )
+        return entries

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

@@ -0,0 +1,155 @@
+import logging
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Cheltenham Borough Council"
+DESCRIPTION = "Source for Cheltenham Borough Council waste collection schedule"
+URL = "https://www.cheltenham.gov.uk"
+COUNTRY = "uk"
+TEST_CASES = {
+    "282 Hatherley Road GL51 6HR": {"property_id": 56299},
+    "Second property": {"property_id": 55297},
+}
+
+LOGGER = logging.getLogger(__name__)
+
+BASE_URL = "https://cheltenham-host01.oncreate.app"
+WEBPAGE_TOKEN = "3e546dda8816902a52a5e3f68096b16d45e279f1f634e9433b899675b5349448"
+SUBPAGE_ID = "PAG0000686GBCNH1"
+CELL_ID = "PCL0005127GBCNH1"
+FRAGMENT_ID = "PCF0019732GBCNH1"
+WIDGET_GROUP_ID = "PWG0002596GBCNH1"
+SUBMIT_FRAGMENT_ID = "PCF0016614GBCNH1"
+
+# Identifiers within the schedule response
+SCHEDULE_OBJECT_ID = "OBJ0000370GBCNH1"
+FRAGMENT_BIN_TYPE = "PCF0019703GBCNH1"
+FRAGMENT_NEXT_DATE = "PCF0019810GBCNH1"
+
+ICON_MAP = {
+    "Refuse": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Food": Icons.BIO_KITCHEN,
+    "Garden": Icons.GARDEN,
+    "Paper": Icons.PAPER,
+    "Card": Icons.PAPER,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "property_id": "Property ID",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "property_id": "Internal numeric property identifier from Cheltenham's bin checker (e.g. 56299)",
+    }
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit https://cheltenham-host01.oncreate.app/w/webpage/collection-lookup, enter your postcode, select your address, then note the numeric property ID shown in the page.",
+}
+
+
+class Source:
+    def __init__(self, property_id: int | str):
+        self._property_id = str(property_id)
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update(
+            {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+                "X-Requested-With": "XMLHttpRequest",
+            }
+        )
+
+        page_url = f"{BASE_URL}/w/webpage/collection-lookup?webpage_subpage_id={SUBPAGE_ID}&webpage_token={WEBPAGE_TOKEN}"
+
+        # Step 1: GET the form page (returns JSON with embedded HTML containing
+        # CSRF token and collection key). The XMLHttpRequest header is what
+        # makes the server return the JSON fragment rather than the full page.
+        r1 = session.get(page_url)
+        r1.raise_for_status()
+        data1 = r1.json().get("data", "")
+
+        form_check_match = re.search(r'name="form_check" value="([a-f0-9]+)"', data1)
+        if not form_check_match:
+            raise Exception("Could not extract CSRF token from form response")
+        form_check = form_check_match.group(1)
+
+        collection_key_match = re.search(r'data-unique_key="(C_[a-f0-9]+)"', data1)
+        if not collection_key_match:
+            raise Exception("Could not extract collection key from form response")
+        collection_key = collection_key_match.group(1)
+
+        # Step 2: Submit property_id to get bin schedule
+        r2 = session.post(
+            page_url,
+            data={
+                "form_check": form_check,
+                "submitted_page_storage_key": "/w/webpage/collection-lookup",
+                "submitted_page_id": SUBPAGE_ID,
+                "submitted_widget_group_id": WIDGET_GROUP_ID,
+                "submitted_widget_group_type": "search",
+                f"payload[{SUBPAGE_ID}][{WIDGET_GROUP_ID}][{CELL_ID}][search][{collection_key}][{FRAGMENT_ID}]": self._property_id,
+                f"payload[{SUBPAGE_ID}][{WIDGET_GROUP_ID}][{CELL_ID}][search][{collection_key}][{SUBMIT_FRAGMENT_ID}]": "Next",
+            },
+        )
+        r2.raise_for_status()
+        data2 = r2.json().get("data", "")
+
+        return self._parse_schedule(data2)
+
+    def _parse_schedule(self, html: str) -> list[Collection]:
+        soup = BeautifulSoup(html, "html.parser")
+        # Restrict to bin-schedule rows; the same response also embeds
+        # address-listing rows that would otherwise confuse the parser.
+        rows = soup.find_all("tr", attrs={"data-base_object_id": SCHEDULE_OBJECT_ID})
+
+        entries = []
+        for row in rows:
+            bin_type_div = row.find(
+                "div", attrs={"data-fragment_id": FRAGMENT_BIN_TYPE}
+            )
+            next_date_div = row.find(
+                "div", attrs={"data-fragment_id": FRAGMENT_NEXT_DATE}
+            )
+            if not bin_type_div or not next_date_div:
+                continue
+
+            bin_type = bin_type_div.get("data-current_value", "").strip()
+            next_date_str = next_date_div.get("data-current_value", "").strip()
+            if not bin_type or not next_date_str or next_date_str == "N/A":
+                continue
+
+            try:
+                next_date = datetime.strptime(next_date_str, "%d/%m/%Y").date()
+            except ValueError:
+                LOGGER.warning(
+                    "Could not parse date %r for bin type %r", next_date_str, bin_type
+                )
+                continue
+
+            icon = None
+            for keyword, mapped_icon in ICON_MAP.items():
+                if keyword.lower() in bin_type.lower():
+                    icon = mapped_icon
+                    break
+
+            entries.append(Collection(date=next_date, t=bin_type, icon=icon))
+
+        if not entries:
+            raise SourceArgumentNotFound(
+                "property_id",
+                self._property_id,
+                "no collection data found — please check your property_id is correct",
+            )
+
+        return entries

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

@@ -0,0 +1,74 @@
+import re
+from datetime import datetime, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Cherwell District Council"
+DESCRIPTION = "Cherwell District Council North Oxfordshire, UK"
+URL = "https://www.cherwell.gov.uk"
+TEST_CASES = {
+    "Test_001": {"uprn": "100120758315"},
+    "Test_002": {"uprn": "100120780449"},
+    "Test_003": {"uprn": 100120777153},
+    "Test_004": {"uprn": 10011931488},
+}
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+REGEX = {
+    "DATES": r"([Green|Blue|Brown]+ Bin)",
+    "ORDINALS": r"(st|nd|rd|th) ",
+}
+ICON_MAP = {
+    "GREEN BIN": Icons.GENERAL_WASTE,
+    "BLUE BIN": Icons.RECYCLING,
+    "BROWN BIN": Icons.BIO_KITCHEN,
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn).zfill(12)
+
+    def fetch(self):
+
+        today = datetime.now()
+        today = today.replace(hour=0, minute=0, second=0, microsecond=0)
+        yr = int(today.year)
+
+        s = requests.Session()
+        r = s.get(
+            f"https://www.cherwell.gov.uk/homepage/129/?uprn={self._uprn}",
+            headers=HEADERS,
+        )
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        boxes = soup.findAll("div", {"class": "boxed"})
+
+        entries = []
+        for box in boxes:
+            title = (
+                box.find("h3", {"class": "bin-collection-tasks__heading"})
+                .text.replace("Your next ", "")
+                .replace(" collection", "")
+            )
+            # Get date, append year, and increment year if date is >1 month in the past.
+            # This tries to deal year-end dates when the YEAR is missing
+            date = box.find("p", {"class": "bin-collection-tasks__date"}).text.strip()
+            date = re.sub(REGEX["ORDINALS"], "", date)
+            date += " " + str(yr)
+            dt = datetime.strptime(date, "%d%B %Y")
+            if (dt - today) < timedelta(days=-31):
+                dt = dt.replace(year=dt.year + 1)
+
+            entries.append(
+                Collection(
+                    date=dt.date(),
+                    t=title,
+                    icon=ICON_MAP.get(title.upper()),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,90 @@
+from datetime import date, timedelta
+
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.ArcGis import (
+    ArcGisError,
+    geocode,
+    query_feature_layer,
+)
+
+TITLE = "Chesapeake, VA"
+DESCRIPTION = "Source for Chesapeake, VA trash collection."
+URL = "https://www.cityofchesapeake.net"
+COUNTRY = "us"
+
+TEST_CASES = {
+    "460 Sawyers Mill Xing": {"address": "460 Sawyers Mill Xing, Chesapeake, VA 23323"},
+}
+
+ICON_MAP = {
+    "Trash": Icons.GENERAL_WASTE,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Full street address including city and state (e.g. '460 Sawyers Mill Xing, Chesapeake, VA 23323')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+MAPSERVER_URL = "https://gis.cityofchesapeake.net/mapping/rest/services/WasteManagement/Trash_Collection_Areas/MapServer/0"
+
+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:
+            location = geocode(self._address)
+        except ArcGisError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        try:
+            features = query_feature_layer(
+                MAPSERVER_URL,
+                geometry=location,
+                out_fields="PICKUP_DAY",
+            )
+        except ArcGisError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        attrs = features[0]
+        pickup_day = (attrs.get("PICKUP_DAY") or "").strip().title()
+
+        if not pickup_day or pickup_day not in WEEKDAYS:
+            raise SourceArgumentNotFound("address", self._address)
+
+        return self._weekly_dates(pickup_day, "Trash")
+
+    @staticmethod
+    def _weekly_dates(day_name: str, waste_type: str) -> list[Collection]:
+        weekday = WEEKDAYS[day_name]
+        today = date.today()
+        days_ahead = (weekday - today.weekday()) % 7
+        next_date = today + timedelta(days=days_ahead)
+        icon = ICON_MAP.get(waste_type)
+        return [
+            Collection(
+                date=next_date + timedelta(weeks=i),
+                t=waste_type,
+                icon=icon,
+            )
+            for i in range(26)
+        ]