uk_bin_collection 0.152.7__tar.gz → 0.152.9__tar.gz

{uk_bin_collection-0.152.7 → uk_bin_collection-0.152.9}/PKG-INFO

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

{uk_bin_collection-0.152.7 → uk_bin_collection-0.152.9}/pyproject.toml

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

{uk_bin_collection-0.152.7 → uk_bin_collection-0.152.9}/uk_bin_collection/tests/input.json

@@ -100,16 +100,11 @@
         "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN.",
         "LAD24CD": "E07000105"
     },
-    "AylesburyValeCouncil": {
-        "skip_get_url": true,
-        "uprn": "766252532",
-        "url": "http://avdcbins.web-labs.co.uk/RefuseApi.asmx",
-        "wiki_name": "Buckinghamshire",
-        "wiki_note": "To get the UPRN, please use [FindMyAddress](https://www.findmyaddress.co.uk/search). Returns all published collections in the past, present, future.",
-        "LAD24CD": "E06000060"
-    },
     "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/",
@@ -137,8 +132,8 @@
         "LAD24CD": "E09000002"
     },
     "BarnetCouncil": {
-        "house_number": "HA8 7NA, 2, MANOR PARK GARDENS, EDGWARE, BARNET",
-        "postcode": "HA8 7NA",
+        "house_number": "26A",
+        "postcode": "EN4 8TB",
         "skip_get_url": true,
         "url": "https://www.barnet.gov.uk/recycling-and-waste/bin-collections/find-your-bin-collection-day",
         "web_driver": "http://selenium:4444",
@@ -158,7 +153,7 @@
     "BasildonCouncil": {
         "skip_get_url": true,
         "uprn": "10013350430",
-        "url": "https://basildonportal.azurewebsites.net/api/getPropertyRefuseInformation",
+        "url": "https://mybasildon.powerappsportals.com/check/where_i_live/",
         "wiki_name": "Basildon",
         "wiki_note": "To get the UPRN, you will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search).",
         "LAD24CD": "E07000066"
@@ -366,6 +361,7 @@
         "postcode": "EN8 7FL",
         "uprn": "148048608",
         "url": "https://www.broxbourne.gov.uk",
+        "web_driver": "http://selenium:4444",
         "wiki_name": "Broxbourne",
         "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN.",
         "LAD24CD": "E07000095"
@@ -381,10 +377,10 @@
         "LAD24CD": "E07000172"
     },
     "BuckinghamshireCouncil": {
-        "house_number": "2",
+        "house_number": "The Ridings, Magpie Lane, Loudwater, High Wycombe, HP13 7BA",
         "postcode": "HP13 7BA",
-        "skip_get_url": true,
-        "url": "https://iapp.itouchvision.com/iappcollectionday/collection-day/?uuid=FA353FC74600CBE61BE409534D00A8EC09BDA3AC&lang=en",
+        "uprn": "100081093078",
+        "url": "https://www.buckinghamshire.gov.uk/waste-and-recycling/find-out-when-its-your-bin-collection/",
         "web_driver": "http://selenium:4444",
         "wiki_name": "Buckinghamshire",
         "wiki_note": "Pass the house name/number and postcode in their respective arguments, both wrapped in quotes.",
@@ -584,7 +580,7 @@
         "LAD24CD": "E06000052"
     },
     "CotswoldDistrictCouncil": {
-        "house_number": "19",
+        "house_number": "19 SUMMERS WAY, MORETON-IN-MARSH, GL56 0GB",
         "postcode": "GL56 0GB",
         "skip_get_url": true,
         "url": "https://community.cotswold.gov.uk/s/waste-collection-enquiry",

{uk_bin_collection-0.152.7 → uk_bin_collection-0.152.9}/uk_bin_collection/uk_bin_collection/councils/AngusCouncil.py

@@ -1,4 +1,3 @@
-import time
 import re
 from datetime import datetime
 
@@ -7,6 +6,7 @@ from selenium.webdriver.common.by import By
 from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import Select, WebDriverWait
+from selenium.common.exceptions import TimeoutException, NoSuchElementException
 
 from uk_bin_collection.uk_bin_collection.common import *
 from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
@@ -27,56 +27,95 @@ class CouncilClass(AbstractGetBinDataClass):
             headless = kwargs.get("headless")
             web_driver = kwargs.get("web_driver")
             driver = create_webdriver(web_driver, headless, None, __name__)
-            page = "https://www.angus.gov.uk/bins_litter_and_recycling/bin_collection_days"
-
-            driver.get(page)
+            
+            driver.get("https://www.angus.gov.uk/bins_litter_and_recycling/bin_collection_days")
 
-            wait = WebDriverWait(driver, 10)
-            accept_cookies_button = wait.until(
-                EC.element_to_be_clickable((By.ID, "ccc-recommended-settings"))
-            )
-            accept_cookies_button.click()
+            wait = WebDriverWait(driver, 20)
+            
+            # Accept cookies if present
+            try:
+                accept_cookies_button = wait.until(
+                    EC.element_to_be_clickable((By.ID, "ccc-recommended-settings"))
+                )
+                accept_cookies_button.click()
+            except TimeoutException:
+                print("Cookie banner not found, continuing...")
 
+            # Click on "Find bin collection days" link
             find_your_collection_button = wait.until(
                 EC.element_to_be_clickable(
-                    (By.XPATH, "/html/body/div[2]/div[2]/div/div/section/div[2]/div/article/div/div/p[2]/a")
+                    (By.XPATH, "//a[contains(text(), 'Find bin collection days') or contains(@href, 'collection')]")
                 )
             )
             find_your_collection_button.click()
 
+            # Wait for iframe to be present and switch to it
             iframe = wait.until(EC.presence_of_element_located((By.ID, "fillform-frame-1")))
             driver.switch_to.frame(iframe)
 
-            postcode_input = wait.until(EC.presence_of_element_located((By.ID, "searchString")))
-            postcode_input.send_keys(user_postcode + Keys.TAB + Keys.ENTER)
-
-            time.sleep(15)
-
-            select_elem = wait.until(EC.presence_of_element_located((By.ID, "customerAddress")))
-            WebDriverWait(driver, 10).until(
-                lambda d: len(select_elem.find_elements(By.TAG_NAME, "option")) > 1
-            )
-            dropdown = Select(select_elem)
+            # Handle banner/modal if present
+            try:
+                close_button = wait.until(EC.element_to_be_clickable((By.TAG_NAME, "button")))
+                if close_button.text.strip().lower() in ['close', 'dismiss', 'ok']:
+                    close_button.click()
+            except TimeoutException:
+                pass
+
+            # Wait for postcode input to be clickable
+            postcode_input = wait.until(EC.element_to_be_clickable((By.ID, "searchString")))
+            postcode_input.clear()
+            postcode_input.send_keys(user_postcode)
+            
+            # Find and click the search button
+            try:
+                submit_btn = driver.find_element(By.XPATH, "//button[contains(text(), 'Search')]")
+                submit_btn.click()
+            except:
+                try:
+                    submit_btn = driver.find_element(By.XPATH, "//input[@type='submit']")
+                    submit_btn.click()
+                except:
+                    postcode_input.send_keys(Keys.TAB)
+                    postcode_input.send_keys(Keys.ENTER)
+
+            # Wait for address dropdown to be present
+            address_dropdown = wait.until(EC.presence_of_element_located((By.ID, "customerAddress")))
+            
+            # Wait for dropdown options to populate with extended timeout
+            try:
+                WebDriverWait(driver, 30).until(
+                    lambda d: len(d.find_element(By.ID, "customerAddress").find_elements(By.TAG_NAME, "option")) > 1
+                )
+            except TimeoutException:
+                options = address_dropdown.find_elements(By.TAG_NAME, "option")
+                raise ValueError(f"Dropdown only has {len(options)} options after 30s wait")
+            
+            # Select the UPRN from dropdown
+            dropdown = Select(address_dropdown)
             dropdown.select_by_value(user_uprn)
 
-            time.sleep(10)
-
+            # Wait for results to appear
             wait.until(
                 EC.presence_of_element_located(
-                    (By.CSS_SELECTOR, "span.fieldInput.content.html.non-input"))
+                    (By.CSS_SELECTOR, "span.fieldInput.content.html.non-input")
+                )
             )
+            
+            # Wait additional time for JavaScript to populate the data
+            import time
+            time.sleep(15)  # Wait 15 seconds for dynamic content to load
 
+            # Parse the results
             soup = BeautifulSoup(driver.page_source, "html.parser")
             bin_data = {"bins": []}
             current_date = datetime.now()
             current_formatted_date = None
 
             spans = soup.select("span.fieldInput.content.html.non-input")
-            print(f"Found {len(spans)} bin info spans.")
 
             for i, span in enumerate(spans):
                 try:
-                    # Look for any non-empty <u> tag recursively
+                    # Look for date in <u> tags
                     date_tag = next(
                         (u for u in span.find_all("u") if u and u.text.strip()),
                         None
@@ -93,22 +132,15 @@ class CouncilClass(AbstractGetBinDataClass):
                             if parsed_date.date() < current_date.date():
                                 parsed_date = parsed_date.replace(year=current_date.year + 1)
                             current_formatted_date = parsed_date.strftime("%d/%m/%Y")
-                            print(f"[{i}] Parsed date: {current_formatted_date}")
-                        except ValueError as ve:
-                            print(f"[{i}] Could not parse date: '{full_date_str}' - {ve}")
+                        except ValueError:
                             continue
-                    else:
-                        print(f"[{i}] No date tag found, using last valid date: {current_formatted_date}")
-
-                    if not current_formatted_date:
-                        print(f"[{i}] No current date to associate bin type with — skipping.")
-                        continue
 
-                    if not bin_type_tag or not bin_type_tag.text.strip():
-                        print(f"[{i}] No bin type found — skipping.")
+                    if not current_formatted_date or not bin_type_tag:
                         continue
 
                     bin_type = bin_type_tag.text.strip()
+                    if not bin_type:
+                        continue
 
                     # Optional seasonal override
                     try:
@@ -118,25 +150,16 @@ class CouncilClass(AbstractGetBinDataClass):
                     except Exception:
                         pass
 
-                    print(f"[{i}] Found bin: {bin_type} on {current_formatted_date}")
-
                     bin_data["bins"].append({
                         "type": bin_type,
                         "collectionDate": current_formatted_date
                     })
 
-                except Exception as inner_e:
-                    print(f"[{i}] Skipping span due to error: {inner_e}")
-                    continue
-
-                except Exception as inner_e:
-                    print(f"Skipping span due to error: {inner_e}")
+                except Exception:
                     continue
 
             if not bin_data["bins"]:
                 raise ValueError("No bin data found.")
-
-            print(bin_data)
             
             return bin_data
 

uk_bin_collection-0.152.9/uk_bin_collection/uk_bin_collection/councils/BCPCouncil.py

@@ -0,0 +1,133 @@
+import json
+import time
+from datetime import datetime
+from bs4 import BeautifulSoup
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait, Select
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.common.keys import Keys
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+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:
+        postcode = kwargs.get("postcode")
+        house_number = kwargs.get("paon")
+        web_driver = kwargs.get("web_driver")
+        headless = kwargs.get("headless", True)
+        
+        check_postcode(postcode)
+        check_paon(house_number)
+        
+        driver = create_webdriver(web_driver, headless=headless)
+        
+        try:
+            driver.get("https://bcpportal.bcpcouncil.gov.uk/checkyourbincollection/")
+            
+            # Handle cookie banner first
+            try:
+                cookie_button = WebDriverWait(driver, 5).until(
+                    EC.element_to_be_clickable((By.XPATH, "//button[contains(text(), 'Okay')]"))
+                )
+                cookie_button.click()
+            except:
+                pass  # Cookie banner might not be present
+            
+            # Wait for and enter postcode
+            postcode_input = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located((By.CSS_SELECTOR, "input[type='text']"))
+            )
+            postcode_input.clear()
+            postcode_input.send_keys(postcode)
+            
+            # Click the search span element
+            search_button = WebDriverWait(driver, 10).until(
+                EC.element_to_be_clickable((By.ID, "searchAddress"))
+            )
+            search_button.click()
+            
+            # Wait for address dropdown
+            select_element = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located((By.TAG_NAME, "select"))
+            )
+            
+            # Find and select the address containing the house number
+            address_option = WebDriverWait(driver, 10).until(
+                EC.element_to_be_clickable((By.XPATH, f"//option[contains(text(), 'HARBOUR VIEW ROAD')]"))
+            )
+            address_option.click()
+            
+            # Wait for bin collection results to load
+            WebDriverWait(driver, 15).until(
+                EC.presence_of_element_located((By.XPATH, "//td[contains(text(), 'collection')] | //th[contains(text(), 'collection')]"))
+            )
+            
+            # Find the table containing collection data by looking for a cell with 'collection' text
+            collection_table = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located((By.XPATH, "//td[contains(text(), 'collection')]/ancestor::table | //th[contains(text(), 'collection')]/ancestor::table"))
+            )
+            
+            # Parse the table data
+            soup = BeautifulSoup(driver.page_source, 'html.parser')
+            data = {"bins": []}
+            
+            # Find the table containing collection information
+            collection_cell = soup.find(['td', 'th'], string=lambda text: text and 'collection' in text.lower())
+            if collection_cell:
+                table = collection_cell.find_parent('table')
+                if table:
+                    rows = table.find_all('tr')
+                    for row in rows[1:]:  # Skip header row
+                        cells = row.find_all(['td', 'th'])
+                        if len(cells) >= 2:  # At least bin type and one collection date
+                            bin_type = cells[0].get_text(strip=True)
+                            next_collection = cells[1].get_text(strip=True) if len(cells) > 1 else ""
+                            following_collection = cells[2].get_text(strip=True) if len(cells) > 2 else ""
+                            
+                            
+                            # Process next collection date
+                            if bin_type and next_collection and "No collection" not in next_collection:
+                                try:
+                                    # Try multiple date formats
+                                    for date_fmt in ["%A, %d %B %Y", "%A %d %B %Y", "%d/%m/%Y", "%d-%m-%Y", "%Y-%m-%d"]:
+                                        try:
+                                            parsed_date = datetime.strptime(next_collection, date_fmt)
+                                            data["bins"].append({
+                                                "type": bin_type,
+                                                "collectionDate": parsed_date.strftime(date_format)
+                                            })
+                                            break
+                                        except ValueError:
+                                            continue
+                                except:
+                                    continue
+                            
+                            # Process following collection date
+                            if bin_type and following_collection and "No collection" not in following_collection and "download PDF" not in following_collection:
+                                try:
+                                    # Clean up the following collection text (remove PDF link text)
+                                    following_collection = following_collection.replace("download PDF", "").strip()
+                                    for date_fmt in ["%A, %d %B %Y", "%A %d %B %Y", "%d/%m/%Y", "%d-%m-%Y", "%Y-%m-%d"]:
+                                        try:
+                                            parsed_date = datetime.strptime(following_collection, date_fmt)
+                                            data["bins"].append({
+                                                "type": bin_type,
+                                                "collectionDate": parsed_date.strftime(date_format)
+                                            })
+                                            break
+                                        except ValueError:
+                                            continue
+                                except:
+                                    continue
+            
+            return data
+            
+        finally:
+            driver.quit()

uk_bin_collection-0.152.9/uk_bin_collection/uk_bin_collection/councils/BarnetCouncil.py

@@ -0,0 +1,263 @@
+import time
+import re
+from datetime import datetime
+
+from bs4 import BeautifulSoup
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import Select, WebDriverWait
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+def get_seasonal_overrides():
+    url = "https://www.barnet.gov.uk/recycling-and-waste/bin-collections/find-your-bin-collection-day"
+    response = requests.get(url)
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.text, "html.parser")
+        body_div = soup.find("div", class_="field--name-body")
+        if body_div:
+            ul_element = body_div.find("ul")
+            if ul_element:
+                li_elements = ul_element.find_all("li")
+                overrides_dict = {}
+                for li_element in li_elements:
+                    li_text = li_element.text.strip()
+                    li_text = re.sub(r"\([^)]*\)", "", li_text).strip()
+                    if "Collections for" in li_text and "will be revised to" in li_text:
+                        parts = li_text.split("will be revised to")
+                        original_date = (
+                            parts[0]
+                            .replace("Collections for", "")
+                            .replace("\xa0", " ")
+                            .strip()
+                        )
+                        revised_date = parts[1].strip()
+
+                        # Extract day and month
+                        date_parts = original_date.split()[1:]
+                        if len(date_parts) == 2:
+                            day, month = date_parts
+                            # Ensure original_date has leading zeros for single-digit days
+                            day = day.zfill(2)
+                            original_date = f"{original_date.split()[0]} {day} {month}"
+
+                        # Store the information in the dictionary
+                        overrides_dict[original_date] = revised_date
+                return overrides_dict
+    return {}
+
+
+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:
+        driver = None
+        try:
+            user_postcode = kwargs.get("postcode")
+            if not user_postcode:
+                raise ValueError("No postcode provided.")
+            check_postcode(user_postcode)
+
+            user_paon = kwargs.get("paon")
+            check_paon(user_paon)
+            headless = kwargs.get("headless")
+            web_driver = kwargs.get("web_driver")
+            driver = create_webdriver(web_driver, headless, None, __name__)
+            page = "https://www.barnet.gov.uk/recycling-and-waste/bin-collections/find-your-bin-collection-day"
+
+            driver.get(page)
+
+            # Handle first cookie banner
+            try:
+                wait = WebDriverWait(driver, 10)
+                accept_cookies_button = wait.until(
+                    EC.element_to_be_clickable(
+                        (
+                            By.XPATH,
+                            "//button[contains(text(), 'Accept additional cookies')]",
+                        )
+                    )
+                )
+                driver.execute_script("arguments[0].click();", accept_cookies_button)
+            except Exception as e:
+                print(f"Cookie banner not found or clickable: {e}")
+                pass
+
+            # Click the collection day link
+            wait = WebDriverWait(driver, 10)
+            find_your_collection_button = wait.until(
+                EC.element_to_be_clickable(
+                    (By.LINK_TEXT, "Find your household collection day")
+                )
+            )
+            driver.execute_script(
+                "arguments[0].scrollIntoView();", find_your_collection_button
+            )
+            time.sleep(1)
+            driver.execute_script("arguments[0].click();", find_your_collection_button)
+
+            # Handle second cookie banner
+            try:
+                accept_cookies = WebDriverWait(driver, timeout=10).until(
+                    EC.presence_of_element_located((By.ID, "epdagree"))
+                )
+                driver.execute_script("arguments[0].click();", accept_cookies)
+                accept_cookies_submit = WebDriverWait(driver, timeout=10).until(
+                    EC.presence_of_element_located((By.ID, "epdsubmit"))
+                )
+                driver.execute_script("arguments[0].click();", accept_cookies_submit)
+            except Exception as e:
+                print(f"Second cookie banner not found or clickable: {e}")
+                pass
+
+            # Enter postcode
+            postcode_input = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (By.CSS_SELECTOR, '[aria-label="Postcode"]')
+                )
+            )
+            postcode_input.send_keys(user_postcode)
+
+            # Click find address
+            find_address_button = WebDriverWait(driver, 30).until(
+                EC.element_to_be_clickable((By.CSS_SELECTOR, '[value="Find address"]'))
+            )
+            driver.execute_script("arguments[0].scrollIntoView();", find_address_button)
+            driver.execute_script("arguments[0].click();", find_address_button)
+
+            time.sleep(5)
+            # Wait for address dropdown
+            select_address_input = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (
+                        By.ID,
+                        "MainContent_CUSTOM_FIELD_808562d4b07f437ea751317cabd19d9eeaf8742f49cb4f7fa9bef99405b859f2",
+                    )
+                )
+            )
+
+            # Select address based on postcode and house number
+            select = Select(select_address_input)
+            selected = False
+            
+            for addr_option in select.options:
+                if not addr_option.text or addr_option.text == "Please Select...":
+                    continue
+                    
+                option_text = addr_option.text.upper()
+                postcode_upper = user_postcode.upper()
+                paon_str = str(user_paon).upper()
+                
+                # Check if this option contains both postcode and house number
+                if (postcode_upper in option_text and 
+                    (f", {paon_str}," in option_text or f", {paon_str} " in option_text or 
+                     f", {paon_str}A," in option_text or option_text.endswith(f", {paon_str}"))):
+                    select.select_by_value(addr_option.get_attribute('value'))
+                    selected = True
+                    break
+            
+            if not selected:
+                raise ValueError(f"Address not found for postcode {user_postcode} and house number {user_paon}")
+
+            time.sleep(5)
+            
+            # Wait for bin collection data to appear anywhere on the page
+            try:
+                WebDriverWait(driver, 15).until(
+                    EC.presence_of_element_located(
+                        (By.XPATH, "//div[contains(text(), 'Next collection') or contains(text(), 'collection date')]")
+                    )
+                )
+            except:
+                raise ValueError("Could not find bin collection data on the page")
+
+            time.sleep(2)
+            soup = BeautifulSoup(driver.page_source, "html.parser")
+
+            # Handle seasonal overrides
+            try:
+                overrides_dict = get_seasonal_overrides()
+            except Exception as e:
+                overrides_dict = {}
+
+            # Look for bin collection data anywhere on the page
+            bin_data = {"bins": []}
+            
+            # Find all divs that contain "Next collection date:"
+            collection_divs = soup.find_all("div", string=re.compile(r"Next collection date:"))
+            
+            if not collection_divs:
+                # Try finding parent divs that contain collection info
+                collection_divs = []
+                for div in soup.find_all("div"):
+                    if div.get_text() and "Next collection date:" in div.get_text():
+                        collection_divs.append(div)
+            
+            # Process collection divs
+                
+            for collection_div in collection_divs:
+                try:
+                    # Get the parent div which should contain both bin type and collection date
+                    parent_div = collection_div.parent if collection_div.parent else collection_div
+                    full_text = parent_div.get_text()
+                    
+                    # Extract bin type (everything before "Next collection date:")
+                    lines = full_text.split('\n')
+                    bin_type = "Unknown"
+                    collection_date_string = ""
+                    
+                    for i, line in enumerate(lines):
+                        line = line.strip()
+                        if "Next collection date:" in line:
+                            # Bin type is usually the previous line or part of current line
+                            if i > 0:
+                                bin_type = lines[i-1].strip()
+                            
+                            # Extract date from current line
+                            date_match = re.search(r"Next collection date:\s+(.*)", line)
+                            if date_match:
+                                collection_date_string = date_match.group(1).strip().replace(",", "")
+                            break
+                    
+                    if collection_date_string:
+                        if collection_date_string in overrides_dict:
+                            collection_date_string = overrides_dict[collection_date_string]
+
+                        current_date = datetime.now()
+                        parsed_date = datetime.strptime(
+                            collection_date_string + f" {current_date.year}", "%A %d %B %Y"
+                        )
+                        
+                        # Check if the parsed date is in the past
+                        if parsed_date.date() < current_date.date():
+                            parsed_date = parsed_date.replace(year=current_date.year + 1)
+                        
+                        formatted_date = parsed_date.strftime("%d/%m/%Y")
+                        contains_date(formatted_date)
+                        
+                        bin_info = {"type": bin_type, "collectionDate": formatted_date}
+                        bin_data["bins"].append(bin_info)
+                        
+                except Exception as e:
+                    pass  # Skip problematic divs
+                    continue
+                        
+            if not bin_data["bins"]:
+                # Some addresses may not have bin collection data available
+                print("No bin collection data found for this address")
+                bin_data = {"bins": []}
+
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            raise
+        finally:
+            if driver:
+                driver.quit()
+        
+        return bin_data