uk_bin_collection 0.152.7__py3-none-any.whl → 0.152.9__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/CopelandBoroughCouncil.py

@@ -1,93 +1,98 @@
-from xml.etree import ElementTree
-
+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
 
 
+# import the wonderful Beautiful Soup and the URL grabber
 class CouncilClass(AbstractGetBinDataClass):
     """
     Concrete classes have to implement all abstract operations of the
-    baseclass. They can also override some
-    operations with a default implementation.
+    base class. They can also override some operations with a default
+    implementation.
     """
 
     def parse_data(self, page: str, **kwargs) -> dict:
-        uprn = kwargs.get("uprn")
-        check_uprn(uprn)
-        council = "CPL"
 
-        # Make SOAP request
+        user_uprn = kwargs.get("uprn")
+        postcode = kwargs.get("postcode")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = "https://waste.cumberland.gov.uk/renderform?t=25&k=E43CEB1FB59F859833EF2D52B16F3F4EBE1CAB6A"
+
+        s = requests.Session()
+
+        # Make the GET request
+        response = s.get(URI)
+
+        # Make a BS4 object
+        soup = BeautifulSoup(response.content, features="html.parser")
+
+        # print(soup)
+
+        token = (soup.find("input", {"name": "__RequestVerificationToken"})).get(
+            "value"
+        )
+
+        formguid = (soup.find("input", {"name": "FormGuid"})).get("value")
+
+        # print(token)
+        # print(formguid)
+
         headers = {
-            "Content-Type": "text/xml; charset=UTF-8",
-            "Referer": "https://collections-copeland.azurewebsites.net/calendar.html",
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Origin": "https://waste.cumberland.gov.uk",
+            "Referer": "https://waste.cumberland.gov.uk/renderform?t=25&k=E43CEB1FB59F859833EF2D52B16F3F4EBE1CAB6A",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36 OPR/98.0.0.0",
+            "X-Requested-With": "XMLHttpRequest",
         }
-        requests.packages.urllib3.disable_warnings()
-        post_data = (
-            '<?xml version="1.0" encoding="utf-8"?>'
-            '<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">'
-            '<soap:Body><getRoundCalendarForUPRN xmlns="http://webaspx-collections.azurewebsites.net/">'
-            "<council>" + council + "</council><UPRN>" + uprn + "</UPRN>"
-            "<from>Chtml</from></getRoundCalendarForUPRN></soap:Body></soap:Envelope>"
-        )
-        response = requests.post(
-            "https://collections-copeland.azurewebsites.net/WSCollExternal.asmx",
+
+        payload = {
+            "__RequestVerificationToken": token,
+            "FormGuid": formguid,
+            "ObjectTemplateID": "25",
+            "Trigger": "submit",
+            "CurrentSectionID": "33",
+            "TriggerCtl": "",
+            "FF265": f"U{user_uprn}",
+            "FF265lbltxt": "Please select your address",
+            "FF265-text": postcode
+        }
+
+        # print(payload)
+
+        response = s.post(
+            "https://waste.cumberland.gov.uk/renderform/Form",
             headers=headers,
-            data=post_data,
+            data=payload,
+        )
+
+        soup = BeautifulSoup(response.content, features="html.parser")
+        for row in soup.find_all("div", class_="resirow"):
+            # Extract the type of collection (e.g., Recycling, Refuse)
+            collection_type_div = row.find("div", class_="col")
+            collection_type = (
+                collection_type_div.get("class")[1]
+                if collection_type_div
+                else "Unknown"
+            )
+
+            # Extract the collection date
+            date_div = row.find("div", style="width:360px;")
+            collection_date = date_div.text.strip() if date_div else "Unknown"
+
+            dict_data = {
+                "type": collection_type,
+                "collectionDate": datetime.strptime(
+                    collection_date, "%A %d %B %Y"
+                ).strftime(date_format),
+            }
+            bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
         )
 
-        if response.status_code != 200:
-            raise ValueError("No bin data found for provided UPRN.")
-
-        # Get HTML from SOAP response
-        xmltree = ElementTree.fromstring(response.text)
-        html = xmltree.find(
-            ".//{http://webaspx-collections.azurewebsites.net/}getRoundCalendarForUPRNResult"
-        ).text
-        # Parse with BS4
-        soup = BeautifulSoup(html, features="html.parser")
-        soup.prettify()
-
-        data = {"bins": []}
-        for bin_type in ["Refuse", "Recycling", "Garden"]:
-            bin_el = soup.find("b", string=bin_type)
-            if bin_el:
-                bin_info = bin_el.next_sibling.split(": ")[1]
-                collection_date = ""
-                results = re.search("([A-Za-z]+ \\d\\d? [A-Za-z]+) then", bin_info)
-                if results:
-                    if results[1] == "Today":
-                        date = datetime.now()
-                    elif results[1] == "Tomorrow":
-                        date = datetime.now() + timedelta(days=1)
-                    else:
-                        date = get_next_occurrence_from_day_month(
-                            datetime.strptime(
-                                results[1] + " " + datetime.now().strftime("%Y"),
-                                "%a %d %b %Y",
-                            )
-                        )
-                    if date:
-                        collection_date = date.strftime(date_format)
-                else:
-                    results2 = re.search("([A-Za-z]+) then", bin_info)
-                    if results2:
-                        if results2[1] == "Today":
-                            collection_date = datetime.now().strftime(date_format)
-                        elif results2[1] == "Tomorrow":
-                            collection_date = (
-                                datetime.now() + timedelta(days=1)
-                            ).strftime(date_format)
-                        else:
-                            collection_date = results2[1]
-
-                if collection_date != "":
-                    dict_data = {
-                        "type": bin_type,
-                        "collectionDate": collection_date,
-                    }
-                    data["bins"].append(dict_data)
-
-        return data
+        return bindata

uk_bin_collection/uk_bin_collection/councils/CotswoldDistrictCouncil.py

@@ -1,5 +1,6 @@
 import time
-from datetime import datetime
+import re
+from datetime import datetime, timedelta
 
 from bs4 import BeautifulSoup
 from selenium.webdriver.common.by import By
@@ -11,8 +12,6 @@ from selenium.webdriver.support.wait import WebDriverWait
 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):
     """
@@ -30,7 +29,8 @@ class CouncilClass(AbstractGetBinDataClass):
 
             house_number = kwargs.get("paon")
             postcode = kwargs.get("postcode")
-            full_address = f"{house_number}, {postcode}"
+            # Use house_number as full address since it contains the complete address
+            full_address = house_number if house_number else f"{house_number}, {postcode}"
             web_driver = kwargs.get("web_driver")
             headless = kwargs.get("headless")
 
@@ -38,81 +38,205 @@ class CouncilClass(AbstractGetBinDataClass):
             driver = create_webdriver(web_driver, headless, None, __name__)
             driver.get(page)
 
-            # If you bang in the house number (or property name) and postcode in the box it should find your property
+            # Wait for page to load completely
             wait = WebDriverWait(driver, 60)
-            address_entry_field = wait.until(
-                EC.element_to_be_clickable((By.XPATH, '//*[@id="combobox-input-22"]'))
-            )
-
-            address_entry_field.send_keys(str(full_address))
-
-            address_entry_field = wait.until(
-                EC.element_to_be_clickable((By.XPATH, '//*[@id="combobox-input-22"]'))
-            )
-            address_entry_field.click()
-            address_entry_field.send_keys(Keys.BACKSPACE)
-            address_entry_field.send_keys(str(full_address[len(full_address) - 1]))
-
-            first_found_address = wait.until(
-                EC.element_to_be_clickable(
-                    (By.XPATH, '//*[@id="dropdown-element-22"]/ul')
-                )
-            )
-
-            first_found_address.click()
-            # Wait for the 'Select your property' dropdown to appear and select the first result
-            next_btn = wait.until(
-                EC.element_to_be_clickable((By.XPATH, "//lightning-button/button"))
-            )
-            next_btn.click()
-            bin_data = wait.until(
-                EC.presence_of_element_located(
-                    (By.XPATH, "//span[contains(text(), 'Container')]")
-                )
-            )
-
+            
+            # Wait for the Salesforce Lightning page to be fully loaded
+            print("Waiting for Salesforce Lightning components to load...")
+            time.sleep(10)
+            
+            # Wait for the address input field to be present
+            try:
+                wait.until(EC.presence_of_element_located((By.XPATH, "//label[contains(text(), 'Enter your address')]")))
+                print("Address label found")
+                time.sleep(5)  # Additional wait for the input field to be ready
+            except Exception as e:
+                print(f"Address label not found: {e}")
+            
+            # Find the address input field using the label
+            try:
+                address_entry_field = driver.find_element(By.XPATH, "//label[contains(text(), 'Enter your address')]/following-sibling::*//input")
+                print("Found address input field using label xpath")
+            except Exception as e:
+                print(f"Could not find address input field: {e}")
+                raise Exception("Could not find address input field")
+            
+            # Clear any existing text and enter the address
+            try:
+                address_entry_field.clear()
+                address_entry_field.send_keys(str(full_address))
+                print(f"Entered address: {full_address}")
+            except Exception as e:
+                print(f"Error entering address: {e}")
+                raise
+            
+            # Click the input field again to trigger the dropdown
+            try:
+                address_entry_field.click()
+                print("Clicked input field to trigger dropdown")
+                time.sleep(3)  # Wait for dropdown to appear
+            except Exception as e:
+                print(f"Error clicking input field: {e}")
+            
+            # Wait for and click the dropdown option
+            try:
+                dropdown_wait = WebDriverWait(driver, 10)
+                dropdown_option = dropdown_wait.until(EC.element_to_be_clickable((By.XPATH, "//li[@role='presentation']")))
+                dropdown_option.click()
+                print("Clicked dropdown option")
+                time.sleep(2)
+            except Exception as e:
+                print(f"Error clicking dropdown option: {e}")
+                raise
+            
+            # Find and click the Next button
+            try:
+                next_wait = WebDriverWait(driver, 10)
+                next_button = next_wait.until(EC.element_to_be_clickable((By.XPATH, "//button[contains(text(), 'Next')]")))
+                next_button.click()
+                print("Clicked Next button")
+                time.sleep(5)  # Wait for the bin collection data to load
+            except Exception as e:
+                print(f"Error clicking Next button: {e}")
+                raise
+            
+            # Wait for the bin collection data table to load
+            try:
+                table_wait = WebDriverWait(driver, 15)
+                table_wait.until(EC.presence_of_element_located((By.XPATH, "//span[contains(text(), 'Collection Day')]")))
+                print("Bin collection data table loaded")
+                time.sleep(3)
+            except Exception as e:
+                print(f"Bin collection table not found: {e}")
+            
             soup = BeautifulSoup(driver.page_source, features="html.parser")
-
-            rows = soup.find_all("tr", class_="slds-hint-parent")
             current_year = datetime.now().year
 
+            # Try multiple approaches to find bin collection data
+            rows = []
+            
+            # Try different table row selectors
+            table_selectors = [
+                "tr.slds-hint-parent",
+                "tr[class*='slds']",
+                "table tr",
+                ".slds-table tr",
+                "tbody tr"
+            ]
+            
+            for selector in table_selectors:
+                rows = soup.select(selector)
+                if rows:
+                    break
+            
+            # If no table rows found, try to find any elements containing collection info
+            if not rows:
+                # Look for any elements that might contain bin collection information
+                collection_elements = soup.find_all(text=re.compile(r'(bin|collection|waste|recycling)', re.I))
+                if collection_elements:
+                    # Try to extract information from the surrounding elements
+                    for element in collection_elements[:10]:  # Limit to first 10 matches
+                        parent = element.parent
+                        if parent:
+                            text = parent.get_text().strip()
+                            if text and len(text) > 10:  # Only consider substantial text
+                                # Try to extract date patterns
+                                date_patterns = re.findall(r'\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b|\b\d{1,2}\s+\w+\s+\d{4}\b', text)
+                                if date_patterns:
+                                    data["bins"].append({
+                                        "type": "General Collection",
+                                        "collectionDate": date_patterns[0]
+                                    })
+                                    break
+            
+            # Process table rows if found
             for row in rows:
-                columns = row.find_all("td")
-                if columns:
-                    container_type = row.find("th").text.strip()
-                    if columns[0].get_text() == "Today":
-                        collection_day = datetime.now().strftime("%a, %d %B")
-                    elif columns[0].get_text() == "Tomorrow":
-                        collection_day = (datetime.now() + timedelta(days=1)).strftime(
-                            "%a, %d %B"
-                        )
-                    else:
-                        collection_day = re.sub(
-                            r"[^a-zA-Z0-9,\s]", "", columns[0].get_text()
-                        ).strip()
+                try:
+                    columns = row.find_all(["td", "th"])
+                    if len(columns) >= 2:
+                        # Try to identify container type and date
+                        container_type = "Unknown"
+                        collection_date = ""
+                        
+                        # Look for header cell (th) for container type
+                        th_element = row.find("th")
+                        if th_element:
+                            container_type = th_element.get_text().strip()
+                        elif columns:
+                            # If no th, use first column as type
+                            container_type = columns[0].get_text().strip()
+                        
+                        # Look for date in subsequent columns
+                        for col in columns[1:] if th_element else columns[1:]:
+                            col_text = col.get_text().strip()
+                            if col_text:
+                                if col_text.lower() == "today":
+                                    collection_date = datetime.now().strftime("%d/%m/%Y")
+                                    break
+                                elif col_text.lower() == "tomorrow":
+                                    collection_date = (datetime.now() + timedelta(days=1)).strftime("%d/%m/%Y")
+                                    break
+                                else:
+                                    # Try to parse various date formats
+                                    try:
+                                        # Clean the text
+                                        clean_text = re.sub(r"[^a-zA-Z0-9,\s/-]", "", col_text).strip()
+                                        
+                                        # Try different date parsing approaches
+                                        date_formats = [
+                                            "%a, %d %B",
+                                            "%d %B %Y",
+                                            "%d/%m/%Y",
+                                            "%d-%m-%Y",
+                                            "%B %d, %Y"
+                                        ]
+                                        
+                                        for fmt in date_formats:
+                                            try:
+                                                parsed_date = datetime.strptime(clean_text, fmt)
+                                                if fmt == "%a, %d %B":  # Add year if missing
+                                                    if parsed_date.replace(year=current_year) < datetime.now():
+                                                        parsed_date = parsed_date.replace(year=current_year + 1)
+                                                    else:
+                                                        parsed_date = parsed_date.replace(year=current_year)
+                                                collection_date = parsed_date.strftime("%d/%m/%Y")
+                                                break
+                                            except ValueError:
+                                                continue
+                                        
+                                        if collection_date:
+                                            break
+                                    except Exception:
+                                        continue
+                        
+                        # Add to data if we have both type and date
+                        if container_type and collection_date and container_type.lower() != "unknown":
+                            data["bins"].append({
+                                "type": container_type,
+                                "collectionDate": collection_date
+                            })
+                except Exception as e:
+                    print(f"Error processing row: {e}")
+                    continue
+            
+            # If no data found, add a debug entry
+            if not data["bins"]:
+                print("No bin collection data found. Page source:")
+                print(driver.page_source[:1000])  # Print first 1000 chars for debugging
 
-                    # Parse the date from the string
-                    parsed_date = datetime.strptime(collection_day, "%a, %d %B")
-                    if parsed_date < datetime(
-                        parsed_date.year, parsed_date.month, parsed_date.day
-                    ):
-                        parsed_date = parsed_date.replace(year=current_year + 1)
-                    else:
-                        parsed_date = parsed_date.replace(year=current_year)
-                    # Format the date as %d/%m/%Y
-                    formatted_date = parsed_date.strftime("%d/%m/%Y")
-
-                    # Add the bin type and collection date to the 'data' dictionary
-                    data["bins"].append(
-                        {"type": container_type, "collectionDate": formatted_date}
-                    )
         except Exception as e:
             # Here you can log the exception if needed
             print(f"An error occurred: {e}")
+            print(f"Full address used: {full_address}")
+            print(f"Page URL: {page}")
+            # Add some debug information
+            if driver:
+                print(f"Current page title: {driver.title}")
+                print(f"Current URL: {driver.current_url}")
             # Optionally, re-raise the exception if you want it to propagate
             raise
         finally:
             # This block ensures that the driver is closed regardless of an exception
             if driver:
                 driver.quit()
-        return data
+        return data

uk_bin_collection/uk_bin_collection/councils/CoventryCityCouncil.py

@@ -18,6 +18,10 @@ class CouncilClass(AbstractGetBinDataClass):
 
         bindata = {"bins": []}
         curr_date = datetime.today()
+        
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
 
         soup = BeautifulSoup(page.content, features="html.parser")
         button = soup.find(
@@ -25,10 +29,10 @@ class CouncilClass(AbstractGetBinDataClass):
             text="Find out which bin will be collected when and sign up for a free email reminder.",
         )
 
-        if button["href"]:
+        if button and button.get("href"):
             URI = button["href"]
             # Make the GET request
-            response = requests.get(URI)
+            response = requests.get(URI, headers=headers)
             soup = BeautifulSoup(response.content, features="html.parser")
             divs = soup.find_all("div", {"class": "editor"})
             for div in divs:

uk_bin_collection/uk_bin_collection/councils/MidlothianCouncil.py

@@ -22,6 +22,15 @@ class CouncilClass(AbstractGetBinDataClass):
         "Next brown bin collection": "Brown Bin",
         "Next food bin collection": "Food Bin",
     }
+    HEADERS = {
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Language": "en-GB,en;q=0.9",
+        "Connection": "keep-alive",
+        "Host": "www.midlothian.gov.uk",
+        "Referer": "https://www.midlothian.gov.uk/info/200284/bins_and_recycling",
+        "Upgrade-Insecure-Requests": "1",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
+    }
 
     def parse_data(self, page: str, **kwargs) -> dict:
 
@@ -46,7 +55,7 @@ class CouncilClass(AbstractGetBinDataClass):
         search_url = self.DIRECTORY_URL.format(quote(postcode))
 
         try:
-            search_results_html = requests.get(search_url)
+            search_results_html = requests.get(search_url, headers=self.HEADERS)
             search_results_html.raise_for_status()
 
             soup = BeautifulSoup(search_results_html.text, "html.parser")
@@ -93,7 +102,7 @@ class CouncilClass(AbstractGetBinDataClass):
                     next_page_url = next_page_link["href"]
 
                     # Send a GET request to the next page
-                    next_response = requests.get(next_page_url)
+                    next_response = requests.get(next_page_url, headers=self.HEADERS)
                     next_response.raise_for_status()  # Raise an exception for HTTP errors
 
                     # Parse the HTML content of the next page
@@ -116,7 +125,7 @@ class CouncilClass(AbstractGetBinDataClass):
     def _fetch_bin_collection_data(self, url: str) -> list:
         """Fetch and parse bin collection data from the given URL."""
         try:
-            bin_collection_html = requests.get(url)
+            bin_collection_html = requests.get(url, headers=self.HEADERS)
             bin_collection_html.raise_for_status()
 
             soup = BeautifulSoup(bin_collection_html.text, "html.parser")

uk_bin_collection/uk_bin_collection/councils/NewcastleUnderLymeCouncil.py

@@ -23,7 +23,8 @@ class CouncilClass(AbstractGetBinDataClass):
         URI = f"https://www.newcastle-staffs.gov.uk/homepage/97/check-your-bin-day?uprn={user_uprn}"
 
         # Make the GET request
-        response = requests.get(URI)
+        request_headers = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'}
+        response = requests.get(URI, headers=request_headers) 
         response.raise_for_status()
         soup = BeautifulSoup(response.text, features="html.parser")
         soup.prettify()

uk_bin_collection/uk_bin_collection/councils/RoyalBoroughofGreenwich.py

@@ -22,12 +22,18 @@ class CouncilClass(AbstractGetBinDataClass):
         check_paon(user_paon)
         bindata = {"bins": []}
 
+        headers = {
+            "Origin": "https://www.royalgreenwich.gov.uk/",
+            "Referer": "https://www.royalgreenwich.gov.uk/info/200171/recycling_and_rubbish/100/bin_collection_days",
+            "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64)",
+        }
+
         user_postcode = user_postcode.replace(" ", "+")
 
         URI = f"https://www.royalgreenwich.gov.uk/site/custom_scripts/apps/waste-collection/new2023/source.php?term={user_postcode}"
 
         # Make the GET request
-        response = requests.get(URI)
+        response = requests.get(URI, headers=headers)
 
         for address in response.json():
             if user_paon in address:
@@ -38,7 +44,7 @@ class CouncilClass(AbstractGetBinDataClass):
 
         data = {"address": collection_address}
 
-        response = requests.post(URI, data=data)
+        response = requests.post(URI, data=data, headers=headers)
 
         response = response.json()
 

uk_bin_collection/uk_bin_collection/councils/SouthwarkCouncil.py

@@ -95,6 +95,28 @@ class CouncilClass(AbstractGetBinDataClass):
             }
             data["bins"].append(dict_data)
 
+        # Extract communal food waste collection information
+        comfood_section = soup.find(
+            "div", {"aria-labelledby": "communalFoodCollectionTitle"}
+        )
+        if comfood_section:
+            comfood_title = comfood_section.find(
+                "p", {"id": "communalFoodCollectionTitle"}
+            ).text
+            comfood_next_collection = (
+                comfood_section.find(text=lambda text: "Next collection" in text)
+                .strip()
+                .split(": ")[1]
+            )
+
+            dict_data = {
+                "type": comfood_title,
+                "collectionDate": datetime.strptime(
+                    comfood_next_collection, "%a, %d %B %Y"
+                ).strftime("%d/%m/%Y"),
+            }
+            data["bins"].append(dict_data)
+
         comrec_section = soup.find(
             "div", {"aria-labelledby": "recyclingCommunalCollectionTitle"}
         )
@@ -137,4 +159,4 @@ class CouncilClass(AbstractGetBinDataClass):
             }
             data["bins"].append(dict_data)
 
-        return data
+        return data

uk_bin_collection/uk_bin_collection/councils/SwindonBoroughCouncil.py

@@ -22,9 +22,10 @@ class CouncilClass(AbstractGetBinDataClass):
         bindata = {"bins": []}
 
         URI = f"https://www.swindon.gov.uk/info/20122/rubbish_and_recycling_collection_days?addressList={user_uprn}&uprnSubmit=Yes"
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64)"}
 
         # Make the GET request
-        response = requests.get(URI)
+        response = requests.get(URI, headers=headers)
 
         # Parse the JSON response
         soup = BeautifulSoup(response.text, "html.parser")

uk_bin_collection/uk_bin_collection/councils/WakefieldCityCouncil.py

@@ -36,7 +36,10 @@ class CouncilClass(AbstractGetBinDataClass):
                 if s.get_text(strip=True).lower() == "bin collections":
                     rows = s.find_next_sibling(
                         "div", {"class": "c-content-section_body"}
-                    ).find_all("div", class_="tablet:l-col-fb-4 u-mt-10")
+                    ).find_all(
+                        "div",
+                        class_=lambda x: x and "tablet:l-col-fb-4" in x and "u-mt-10" in x
+                    )
 
                     for row in rows:
                         title_elem = row.find("div", class_="u-mb-4")