uk_bin_collection 0.153.0__tar.gz → 0.154.0__tar.gz

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: uk_bin_collection
-Version: 0.153.0
+Version: 0.154.0
 Summary: Python Lib to collect UK Bin Data
 Author: Robert Bradley
 Author-email: robbrad182@gmail.com

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "uk_bin_collection"
-version = "0.153.0"
+version = "0.154.0"
 description = "Python Lib to collect UK Bin Data"
 readme = "README.md"
 authors = ["Robert Bradley <robbrad182@gmail.com>"]

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/tests/input.json

@@ -102,12 +102,9 @@
     },
     "BCPCouncil": {
         "LAD24CD": "E06000058",
-        "house_number": "3 HARBOUR VIEW ROAD, POOLE, BH14 0PD",
-        "postcode": "BH14 0PD",
-        "web_driver": "http://selenium:4444",
         "skip_get_url": true,
         "uprn": "100040810214",
-        "url": "https://online.bcpcouncil.gov.uk/bindaylookup/",
+        "url": "https://bcpportal.bcpcouncil.gov.uk/checkyourbincollection",
         "wiki_name": "Bournemouth, Christchurch and Poole",
         "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
     },
@@ -888,7 +885,7 @@
     "ErewashBoroughCouncil": {
         "skip_get_url": true,
         "uprn": "10003582028",
-        "url": "https://map.erewash.gov.uk/isharelive.web/myerewash.aspx",
+        "url": "https://www.erewash.gov.uk",
         "wiki_name": "Erewash",
         "wiki_note": "Pass the UPRN. You can find it using [FindMyAddress](https://www.findmyaddress.co.uk/search).",
         "LAD24CD": "E07000036"
@@ -995,7 +992,7 @@
     },
     "GlasgowCityCouncil": {
         "uprn": "906700034497",
-        "url": "https://onlineservices.glasgow.gov.uk/forms/RefuseAndRecyclingWebApplication/AddressSearch.aspx",
+        "url": "https://onlineservices.glasgow.gov.uk/forms/refuseandrecyclingcalendar/AddressSearch.aspx",
         "skip_get_url": true,
         "wiki_name": "Glasgow City",
         "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN.",
@@ -1779,21 +1776,22 @@
         "LAD24CD": "E06000065"
     },
     "NorthumberlandCouncil": {
-        "house_number": "22",
-        "postcode": "NE46 1UQ",
+        "uprn": "010096302588",
+        "postcode": "NE65 0ZP",
         "skip_get_url": true,
-        "url": "https://www.northumberland.gov.uk/Waste/Household-waste/Household-bin-collections/Bin-Calendars.aspx",
+        "url": "https://bincollection.northumberland.gov.uk/postcode",
         "web_driver": "http://selenium:4444",
         "wiki_name": "Northumberland",
-        "wiki_note": "Pass the house number and postcode in their respective parameters. This parser requires a Selenium webdriver.",
+        "wiki_note": "Pass the UPRN. You can find it using [FindMyAddress](https://www.findmyaddress.co.uk/search).",
         "LAD24CD": "E06000057"
     },
     "NorwichCityCouncil": {
-        "uprn": "100090888980",
-        "url": "https://www.norwich.gov.uk",
-        "wiki_command_url_override": "https://www.norwich.gov.uk",
+        "house_number": "2",
+        "postcode": "NR2 3TT",
+        "url": "https://bnr-wrp.whitespacews.com",
+        "wiki_command_url_override": "hhttps://bnr-wrp.whitespacews.com",
         "wiki_name": "Norwich",
-        "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN.",
+        "wiki_note": "Pass the house number and postcode in their respective parameters.",
         "LAD24CD": "E07000148"
     },
     "NottinghamCityCouncil": {
@@ -2804,4 +2802,4 @@
         "wiki_note": "Provide your UPRN.",
         "LAD24CD": "E06000014"
     }
-}
+}

uk_bin_collection-0.154.0/uk_bin_collection/uk_bin_collection/councils/BCPCouncil.py

@@ -0,0 +1,58 @@
+import time
+
+import requests
+from dateutil.relativedelta import relativedelta
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+# import the wonderful Beautiful Soup and the URL grabber
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+        # Make a BS4 object
+        uprn = kwargs.get("uprn")
+        # usrn = kwargs.get("paon")
+        check_uprn(uprn)
+        # check_usrn(usrn)
+        bindata = {"bins": []}
+
+        # uprn = uprn.zfill(12)
+
+        API_URL = "https://prod-17.uksouth.logic.azure.com/workflows/58253d7b7d754447acf9fe5fcf76f493/triggers/manual/paths/invoke?api-version=2016-06-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=TAvYIUFj6dzaP90XQCm2ElY6Cd34ze05I3ba7LKTiBs"
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "*/*",
+            "User-Agent": "Mozilla/5.0",
+            "Referer": "https://bcpportal.bcpcouncil.gov.uk/",
+        }
+        s = requests.session()
+        data = {
+            "uprn": uprn,
+        }
+
+        r = s.post(API_URL, json=data, headers=headers)
+        r.raise_for_status()
+
+        data = r.json()
+        rows_data = data["data"]
+        for row in rows_data:
+            bin_type = row["wasteContainerUsageTypeDescription"]
+            collections = row["scheduleDateRange"]
+            for collection in collections:
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": datetime.strptime(
+                        collection, "%Y-%m-%d"
+                    ).strftime(date_format),
+                }
+                bindata["bins"].append(dict_data)
+
+        return bindata

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/uk_bin_collection/councils/BasingstokeCouncil.py

@@ -1,6 +1,8 @@
-from bs4 import BeautifulSoup
 from datetime import datetime
+
 import requests
+from bs4 import BeautifulSoup
+
 from uk_bin_collection.uk_bin_collection.common import *
 from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
 
@@ -10,6 +12,7 @@ COLLECTION_KINDS = {
     "glass": "rteelem_ctl03_pnlCollections_Glass",
     # Garden waste data is only returned if the property is subscribed to the Garden Waste service
     "garden": "rteelem_ctl03_pnlCollections_GardenWaste",
+    "food": "rteelem_ctl03_pnlCollections_Food",
 }
 
 

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/uk_bin_collection/councils/BrightonandHoveCityCouncil.py

@@ -72,7 +72,9 @@ class CouncilClass(AbstractGetBinDataClass):
                     break
 
             if not found:
-                raise Exception(f"Address containing '{user_paon}' not found in dropdown options")
+                raise Exception(
+                    f"Address containing '{user_paon}' not found in dropdown options"
+                )
 
             submit_btn = wait.until(
                 EC.presence_of_element_located(
@@ -84,7 +86,7 @@ class CouncilClass(AbstractGetBinDataClass):
 
             results = wait.until(
                 EC.presence_of_element_located(
-                    (By.XPATH, f'//span[contains(@class,"collection-sub")]')
+                    (By.XPATH, f'//div[contains(@class,"mx-name-listView1")]')
                 )
             )
 
@@ -96,44 +98,21 @@ class CouncilClass(AbstractGetBinDataClass):
             current_date = datetime.now()
 
             # Find all elements with class starting with 'mx-name-index-'
-            bins = soup.find_all(class_=lambda x: x and x.startswith("mx-name-index-"))
+            bin_view = soup.find(class_="mx-name-listView1")
+            bins = bin_view.find_all(
+                class_=lambda x: x and x.startswith("mx-name-index-")
+            )
 
             for bin_item in bins:
-                bin_type = bin_item.find(class_="collection-main").text.strip()
-                day_of_week_elements = bin_item.find_all(class_="collection-header")
-                bin_date = None
-
-                for elem in day_of_week_elements:
-                    if (
-                        elem.text.strip() != bin_type
-                    ):  # Avoid taking the bin type as the date
-                        next_sibling = elem.find_next_sibling()
-                        if next_sibling:
-                            bin_date_str = next_sibling.text.strip()
-                            try:
-                                # Try parsing the date string in the format 'dd Month' (e.g., '30 Dec', '5 January')
-                                bin_date = datetime.strptime(bin_date_str, "%d %b")
-                            except ValueError:
-                                try:
-                                    # If the above format fails, try 'dd MonthName' (e.g., '30 December', '5 January')
-                                    bin_date = datetime.strptime(bin_date_str, "%d %B")
-                                except ValueError:
-                                    pass
-
-                            if bin_date:
-                                # Set the year based on the logic provided
-                                if bin_date.month < current_date.month:
-                                    bin_date = bin_date.replace(
-                                        year=current_date.year + 1
-                                    )
-                                else:
-                                    bin_date = bin_date.replace(year=current_date.year)
-                                # Format the date to the desired format
-                                bin_date = bin_date.strftime("%d/%m/%Y")
-                                break
+                bin_type = bin_item.find(class_="mx-name-text31").text.strip()
+
+                bin_date_str = bin_item.find(class_="mx-name-text29").text.strip()
+
+                bin_date = datetime.strptime(bin_date_str, "%d %B %Y")
+                bin_date = bin_date.strftime(date_format)
+
                 dict_data = {"type": bin_type, "collectionDate": bin_date}
                 data["bins"].append(dict_data)
-                print(data)
         except Exception as e:
             # Here you can log the exception if needed
             print(f"An error occurred: {e}")

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/uk_bin_collection/councils/CastlepointDistrictCouncil.py

@@ -26,7 +26,9 @@ class CouncilClass(AbstractGetBinDataClass):
         uprn = kwargs.get("uprn")
         check_uprn(uprn)
 
-        post_url = "https://apps.castlepoint.gov.uk/cpapps/index.cfm?fa=myStreet.displayDetails"
+        base_url = "https://apps.castlepoint.gov.uk/cpapps/"
+
+        post_url = f"{base_url}index.cfm?fa=myStreet.displayDetails"
         post_header_str = (
             "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,"
             "image/apng,"
@@ -51,31 +53,60 @@ class CouncilClass(AbstractGetBinDataClass):
         soup = BeautifulSoup(post_response.text, features="html.parser")
         soup.prettify()
 
+        calMonthNext = f"{base_url}{soup.select_one("div.calMonthNext a")["href"]}"
+        nextmonth_response = requests.post(
+            calMonthNext, headers=post_headers, data=form_data, verify=False
+        )
+        soup_nextmonth = BeautifulSoup(nextmonth_response.text, features="html.parser")
+        soup_nextmonth.prettify()
+
         data = {"bins": []}
-        collection_tuple = []
 
-        calendar = soup.find("table", class_="calendar")
-        month = datetime.strptime(
-            soup.find("div", class_="calMonthCurrent").get_text(), "[%b]"
-        ).strftime("%m")
-        year = datetime.strptime(
-            soup.find("h1").get_text(), "About my Street - %B %Y"
-        ).strftime("%Y")
-
-        pink_days = [
-            day.get_text().strip() for day in calendar.find_all("td", class_="pink")
-        ]
-        black_days = [
-            day.get_text().strip() for day in calendar.find_all("td", class_="normal")
-        ]
-
-        for day in pink_days:
-            collection_date = datetime(year=int(year), month=int(month), day=int(day))
-            collection_tuple.append(("Pink collection", collection_date))
-
-        for day in black_days:
-            collection_date = datetime(year=int(year), month=int(month), day=int(day))
-            collection_tuple.append(("Normal collection", collection_date))
+        def parse_calendar_month(soup_one_month):
+            out = []
+
+            calendar = soup_one_month.find("table", class_="calendar")
+            if not calendar:
+                return out  # be robust
+
+            # e.g. "[Aug]"
+            month_txt = soup_one_month.find("div", class_="calMonthCurrent").get_text(
+                strip=True
+            )
+            month = datetime.strptime(month_txt, "[%b]").strftime("%m")
+
+            # e.g. "About my Street - August 2025"
+            year_txt = soup_one_month.find("h1").get_text(strip=True)
+            year = datetime.strptime(year_txt, "About my Street - %B %Y").strftime("%Y")
+
+            pink_days = [
+                td.get_text(strip=True) for td in calendar.find_all("td", class_="pink")
+            ]
+            black_days = [
+                td.get_text(strip=True)
+                for td in calendar.find_all("td", class_="normal")
+            ]
+
+            for day in pink_days:
+                out.append(
+                    (
+                        "Pink collection",
+                        datetime(year=int(year), month=int(month), day=int(day)),
+                    )
+                )
+            for day in black_days:
+                out.append(
+                    (
+                        "Normal collection",
+                        datetime(year=int(year), month=int(month), day=int(day)),
+                    )
+                )
+
+            return out
+
+        collection_tuple = []
+        for s in (soup, soup_nextmonth):
+            collection_tuple.extend(parse_calendar_month(s))
 
         ordered_data = sorted(collection_tuple, key=lambda x: x[1])
 

uk_bin_collection-0.154.0/uk_bin_collection/uk_bin_collection/councils/ErewashBoroughCouncil.py

@@ -0,0 +1,59 @@
+import json
+
+from bs4 import BeautifulSoup
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+# import the wonderful Beautiful Soup and the URL grabber
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+        data = {"bins": []}
+        uprn = kwargs.get("uprn")
+        check_uprn(uprn)
+
+        label_map = {
+            "domestic-waste-collection-service": "Household Waste",
+            "recycling-collection-service": "Recycling",
+            "garden-waste-collection-service": "Garden Waste",
+        }
+
+        requests.packages.urllib3.disable_warnings()
+        response = requests.get(
+            f"https://www.erewash.gov.uk/bbd-whitespace/one-year-collection-dates-without-christmas?uprn={uprn}",
+            headers={"User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64)"},
+        )
+        # Parse the JSON response
+        payload = response.json()
+        bin_collection = json.loads(payload) if isinstance(payload, str) else payload
+
+        cd = next(
+            i["settings"]["collection_dates"]
+            for i in bin_collection
+            if i.get("command") == "settings"
+        )
+
+        for month in cd.values():
+            for e in month:
+                d = e["date"]  # "YYYY-MM-DD"
+                label = label_map.get(
+                    e.get("service-identifier"),
+                    e.get("service") or e.get("service-identifier"),
+                )
+
+                dict_data = {
+                    "type": label,
+                    "collectionDate": datetime.strptime(d, "%Y-%m-%d").strftime(
+                        date_format
+                    ),
+                }
+                data["bins"].append(dict_data)
+
+        return data

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/uk_bin_collection/councils/FarehamBoroughCouncil.py

@@ -38,11 +38,14 @@ class CouncilClass(AbstractGetBinDataClass):
         if "rows" in bin_data:
             collection_str = bin_data["rows"][0]["DomesticBinDay"]
 
-            results = re.findall(r"(\d\d?\/\d\d?\/\d{4}) \((\w*)\)", collection_str)
+            results = re.findall(r'(\d{1,2}/\d{1,2}/\d{4}|today)\s*\(([^)]+)\)', collection_str)
 
             if results:
                 for result in results:
-                    collection_date = datetime.strptime(result[0], "%d/%m/%Y")
+                    if (result[0] == "today"):
+                        collection_date = datetime.today()
+                    else:
+                        collection_date = datetime.strptime(result[0], "%d/%m/%Y")
                     dict_data = {
                         "type": result[1],
                         "collectionDate": collection_date.strftime(date_format),

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/uk_bin_collection/councils/FolkstoneandHytheDistrictCouncil.py

@@ -74,6 +74,28 @@ class CouncilClass(AbstractGetBinDataClass):
                     }
                     bindata["bins"].append(dict_data)
 
+        # Extract the Garden Waste schedule
+        garden_waste_section = soup.find(
+            "span", text=lambda x: x and "Garden Waste" in x
+        )
+        if garden_waste_section:
+            bin_types = garden_waste_section.text.replace("Garden Waste: ", "").split(
+                " / "
+            )
+            garden_waste_dates = garden_waste_section.find_next("ul").find_all("li")
+            for date in garden_waste_dates:
+                for bin_type in bin_types:
+                    dict_data = {
+                        "type": bin_type.strip(),
+                        "collectionDate": datetime.strptime(
+                            remove_ordinal_indicator_from_date_string(
+                                date.text.strip()
+                            ),
+                            "%A %d %B %Y",
+                        ).strftime("%d/%m/%Y"),
+                    }
+                    bindata["bins"].append(dict_data)
+
         bindata["bins"].sort(
             key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
         )

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/uk_bin_collection/councils/GlasgowCityCouncil.py

@@ -18,7 +18,7 @@ class CouncilClass(AbstractGetBinDataClass):
         try:
             user_uprn = kwargs.get("uprn")
             check_uprn(user_uprn)
-            url = f"https://onlineservices.glasgow.gov.uk/forms/RefuseAndRecyclingWebApplication/CollectionsCalendar.aspx?UPRN={user_uprn}"
+            url = f"https://onlineservices.glasgow.gov.uk/forms/refuseandrecyclingcalendar/CollectionsCalendar.aspx?UPRN={user_uprn}"
             if not user_uprn:
                 # This is a fallback for if the user stored a URL in old system. Ensures backwards compatibility.
                 url = kwargs.get("url")

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/uk_bin_collection/councils/HartlepoolBoroughCouncil.py

@@ -73,7 +73,9 @@ class CouncilClass(AbstractGetBinDataClass):
         for div in soup.find_all("div"):
             # Extract bin type and date from the span tag
             text = div.find("span").text.strip()
-            bin_type, date = text.split(" ", 1)
+            parts = text.split(" ")
+            date = parts[-1]  # assume the last token is the date
+            bin_type = " ".join(parts[:-1])
             dict_data = {
                 "type": bin_type,
                 "collectionDate": date,

{uk_bin_collection-0.153.0 → uk_bin_collection-0.154.0}/uk_bin_collection/uk_bin_collection/councils/NorthHertfordshireDistrictCouncil.py

@@ -125,23 +125,6 @@ class CouncilClass(AbstractGetBinDataClass):
             # Wait for the page to load - giving it extra time
             time.sleep(5)
 
-            # Use only the selector that we know works
-            # print("Looking for bin type elements...")
-            try:
-                bin_type_selector = (
-                    By.CSS_SELECTOR,
-                    "div.formatting_bold.formatting_size_bigger.formatting span.value-as-text",
-                )
-                WebDriverWait(driver, 15).until(
-                    EC.presence_of_element_located(bin_type_selector)
-                )
-                # print(f"Found bin type elements with selector: {bin_type_selector}")
-            except TimeoutException:
-                # print("Could not find bin type elements. Taking screenshot for debugging...")
-                screenshot_path = f"bin_type_error_{int(time.time())}.png"
-                driver.save_screenshot(screenshot_path)
-                # print(f"Screenshot saved to {screenshot_path}")
-
             # Create BS4 object from driver's page source
             # print("Parsing page with BeautifulSoup...")
             soup = BeautifulSoup(driver.page_source, features="html.parser")
@@ -149,122 +132,37 @@ class CouncilClass(AbstractGetBinDataClass):
             # Initialize data dictionary
             data = {"bins": []}
 
-            # Looking for bin types in the exact HTML structure
-            bin_type_elements = soup.select(
-                "div.page_cell.contains_widget:first-of-type div.formatting_bold.formatting_size_bigger.formatting span.value-as-text"
-            )
-            # print(f"Found {len(bin_type_elements)} bin type elements")
-
-            # Look specifically for date elements with the exact structure
-            date_elements = soup.select("div.col-sm-12.font-xs-3xl span.value-as-text")
-            hidden_dates = soup.select(
-                "div.col-sm-12.font-xs-3xl input[type='hidden'][value*='/']"
-            )
-
-            # print(f"Found {len(bin_type_elements)} bin types and {len(date_elements)} date elements")
-
-            # We need a smarter way to match bin types with their dates
-            bin_count = 0
+            for row in soup.select(".listing_template_row"):
+                # Title (waste stream) is the first <p> in the section
+                first_p = row.find("p")
+                if not first_p:
+                    continue
+                stream = first_p.get_text(" ", strip=True)
 
-            # Map of bin types to their collection dates
-            bin_date_map = {}
+                for p in row.find_all("p"):
+                    t = p.get_text("\n", strip=True)
 
-            # Extract all date strings that look like actual dates
-            date_texts = []
-            date_pattern = re.compile(
-                r"(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)\s+\d+(?:st|nd|rd|th)?\s+\w+\s+\d{4}",
-                re.IGNORECASE,
-            )
+                    if re.search(r"\bNext collection\b", t, flags=re.I):
+                        # Expect format: "Next collection\nTuesday 16th September 2025"
+                        parts = [x.strip() for x in t.split("\n") if x.strip()]
+                        if len(parts) >= 2:
+                            next_collection_display = parts[-1]  # last line
 
-            for element in date_elements:
-                text = element.get_text(strip=True)
-                if date_pattern.search(text):
-                    date_texts.append(text)
-                    # print(f"Found valid date text: {text}")
-
-            # Find hidden date inputs with values in DD/MM/YYYY format
-            hidden_date_values = []
-            for hidden in hidden_dates:
-                value = hidden.get("value", "")
-                if re.match(r"\d{1,2}/\d{1,2}/\d{4}", value):
-                    hidden_date_values.append(value)
-                    # print(f"Found hidden date value: {value}")
-
-            # When filtering date elements
-            date_elements = soup.select("div.col-sm-12.font-xs-3xl span.value-as-text")
-            valid_date_elements = []
-
-            for element in date_elements:
-                text = element.get_text(strip=True)
-                if contains_date(text):
-                    valid_date_elements.append(element)
-                    # print(f"Found valid date element: {text}")
-                else:
-                    pass
-                    # print(f"Skipping non-date element: {text}")
-
-            # print(f"Found {len(bin_type_elements)} bin types and {len(valid_date_elements)} valid date elements")
-
-            # When processing each bin type
-            for i, bin_type_elem in enumerate(bin_type_elements):
-                bin_type = bin_type_elem.get_text(strip=True)
-
-                # Try to find a date for this bin type
-                date_text = None
-
-                # Look for a valid date element
-                if i < len(valid_date_elements):
-                    date_elem = valid_date_elements[i]
-                    date_text = date_elem.get_text(strip=True)
-
-                # If we don't have a valid date yet, try using the hidden input
-                if not date_text or not contains_date(date_text):
-                    if i < len(hidden_dates):
-                        date_value = hidden_dates[i].get("value")
-                        if contains_date(date_value):
-                            date_text = date_value
-
-                # Skip if we don't have a valid date
-                if not date_text or not contains_date(date_text):
-                    # print(f"No valid date found for bin type: {bin_type}")
-                    continue
+                # Build record
+                next_date = datetime.strptime(
+                    remove_ordinal_indicator_from_date_string(next_collection_display),
+                    "%A %d %B %Y",
+                )
 
-                # print(f"Found bin type: {bin_type} with date: {date_text}")
+                # Create bin entry
+                bin_entry = {
+                    "type": stream,
+                    "collectionDate": next_date.strftime(date_format),
+                }
 
-                try:
-                    # Clean up the date text
-                    date_text = remove_ordinal_indicator_from_date_string(date_text)
-
-                    # Try to parse the date
-                    try:
-                        collection_date = datetime.strptime(
-                            date_text, "%A %d %B %Y"
-                        ).date()
-                    except ValueError:
-                        try:
-                            collection_date = datetime.strptime(
-                                date_text, "%d/%m/%Y"
-                            ).date()
-                        except ValueError:
-                            # Last resort
-                            collection_date = parse(date_text).date()
-
-                    # Create bin entry
-                    bin_entry = {
-                        "type": bin_type,
-                        "collectionDate": collection_date.strftime(date_format),
-                    }
-
-                    # Add to data
-                    data["bins"].append(bin_entry)
-                    bin_count += 1
-                    # print(f"Added bin entry: {bin_entry}")
-
-                except Exception as e:
-                    pass
-                    # print(f"Error parsing date '{date_text}': {str(e)}")
-
-            # print(f"Successfully parsed {bin_count} bin collections")
+                # Add to data
+                data["bins"].append(bin_entry)
+                # print(f"Added bin entry: {bin_entry}")
 
             if not data["bins"]:
                 # print("No bin data found. Saving page for debugging...")