uk_bin_collection 0.134.1__py3-none-any.whl → 0.135.2__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/BolsoverCouncil.py

@@ -0,0 +1,298 @@
+import time
+
+import requests
+
+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:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        SESSION_URL = "https://selfservice.bolsover.gov.uk/authapi/isauthenticated?uri=https%253A%252F%252Fselfservice.bolsover.gov.uk%252Fservice%252FCheck_your_Bin_Day&hostname=selfservice.bolsover.gov.uk&withCredentials=true"
+
+        API_URL = "https://selfservice.bolsover.gov.uk/apibroker/runLookup"
+
+        data = {
+            "formValues": {"Bin Collection": {"uprnLoggedIn": {"value": user_uprn}}},
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://selfservice.bolsover.gov.uk/fillform/?iframe_id=fillform-frame-1&db_id=",
+        }
+        s = requests.session()
+        r = s.get(SESSION_URL)
+        r.raise_for_status()
+        session_data = r.json()
+        sid = session_data["auth-session"]
+        params = {
+            "id": "6023d37e037c3",
+            "repeat_against": "",
+            "noRetry": "true",
+            "getOnlyTokens": "undefined",
+            "log_id": "",
+            "app_name": "AF-Renderer::Self",
+            # unix_timestamp
+            "_": str(int(time.time() * 1000)),
+            "sid": sid,
+        }
+
+        r = s.post(API_URL, json=data, headers=headers, params=params)
+        r.raise_for_status()
+
+        data = r.json()
+        rows_data = data["integration"]["transformed"]["rows_data"]["0"]
+        if not isinstance(rows_data, dict):
+            raise ValueError("Invalid data returned from API")
+
+        # print(rows_data)
+
+        route = rows_data["Route"]
+
+        # print(route)
+
+        def get_route_number(route):
+            if route[:2] == "Mo":
+                return 0
+            elif route[:2] == "Tu":
+                return 1
+            elif route[:2] == "We":
+                return 2
+            elif route[:2] == "Th":
+                return 3
+            elif route[:2] == "Fr":
+                return 4
+            else:
+                return None  # Default case if none of the conditions match
+
+        dayOfCollectionAsNumber = get_route_number(route)
+        # print(dayOfCollectionAsNumber)
+
+        def calculate_collection_date(
+            dayOfCollectionAsNumber,
+            currentDayAsNumber,
+            today,
+            dayDiffPlus,
+            dayDiffMinus,
+        ):
+            if dayOfCollectionAsNumber == currentDayAsNumber:
+                return today
+            elif dayOfCollectionAsNumber > currentDayAsNumber:
+                return today + timedelta(days=dayDiffPlus)
+            else:
+                return today + timedelta(days=dayDiffMinus)
+
+        # Example usage
+        today = datetime.today()  # Current date
+        currentDayAsNumber = today.weekday()
+        dayDiffPlus = dayOfCollectionAsNumber - currentDayAsNumber
+        dayDiffMinus = dayOfCollectionAsNumber - currentDayAsNumber + 7
+
+        week1 = calculate_collection_date(
+            dayOfCollectionAsNumber,
+            currentDayAsNumber,
+            today,
+            dayDiffPlus,
+            dayDiffMinus,
+        )
+        week2 = week1 + timedelta(days=7)
+        week3 = week2 + timedelta(days=7)
+        week4 = week3 + timedelta(days=7)
+
+        # print(week1.strftime(date_format))
+        # print(week2.strftime(date_format))
+        # print(week3.strftime(date_format))
+        # print(week4.strftime(date_format))
+
+        greenSusStart = datetime.strptime("2024-11-08", "%Y-%m-%d")
+        greenSusEnd = datetime.strptime("2025-03-18", "%Y-%m-%d")
+
+        def is_within_green_sus(dtDay0, greenSusStart, greenSusEnd):
+            return "Yes" if greenSusStart <= dtDay0 < greenSusEnd else "No"
+
+        week1InSus = is_within_green_sus(week1, greenSusStart, greenSusEnd)
+        week2InSus = is_within_green_sus(week2, greenSusStart, greenSusEnd)
+        week3InSus = is_within_green_sus(week3, greenSusStart, greenSusEnd)
+        week4InSus = is_within_green_sus(week4, greenSusStart, greenSusEnd)
+
+        # print(week1InSus)
+        # print(week2InSus)
+        # print(week3InSus)
+        # print(week4InSus)
+
+        WeekBlack = rows_data["WeekBlack"]
+        WeekBandG = rows_data["WeekBandG"]
+
+        if WeekBlack == "1":
+            WeekBandG = ""
+        if WeekBandG == "1":
+            WeekBlack = ""
+
+        def determine_bin_collection_week1(
+            txtBlack, txtBurgGreen, dtDay0, today, week1InSus
+        ):
+            # Check for empty values
+            if txtBlack == "" and txtBurgGreen == "":
+                return ""
+
+            # Black Bin Collection
+            if txtBlack == "1" and dtDay0 >= today:
+                return "Black Bin"
+
+            # Burgundy Bin Collection
+            if txtBurgGreen == "1" and dtDay0 > today:
+                if week1InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week1InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            # Default cases based on week1InSus
+            if txtBlack == "" and dtDay0 >= today:
+                if week1InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week1InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            return ""  # Default empty case
+
+        def determine_bin_collection_week2(
+            txtBlack, txtBurgGreen, dtDay7, today, week2InSus
+        ):
+            # Check for empty values
+            if txtBlack == "" and txtBurgGreen == "":
+                return ""
+
+            # Black Bin Collection
+            if txtBlack == "" and dtDay7 >= today:
+                return "Black Bin"
+
+            # Burgundy Bin Collection (week2InSus check)
+            if txtBurgGreen == "1" and dtDay7 > today:
+                if week2InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week2InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            # Burgundy Bin Collection for txtBlack = '1'
+            if txtBlack == "1" and dtDay7 >= today:
+                if week2InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week2InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            return ""  # Default empty case
+
+        def determine_bin_collection_week3(
+            txtBlack, txtBurgGreen, dtDay14, today, week3InSus
+        ):
+            # Check for empty values
+            if txtBlack == "" and txtBurgGreen == "":
+                return ""
+
+            # Black Bin Collection
+            if txtBlack == "1" and dtDay14 >= today:
+                return "Black Bin"
+
+            # Burgundy Bin Collection (week3InSus check)
+            if txtBurgGreen == "1" and dtDay14 > today:
+                if week3InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week3InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            # Burgundy Bin Collection for txtBlack = ''
+            if txtBlack == "" and dtDay14 >= today:
+                if week3InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week3InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            return ""  # Default empty case
+
+        def determine_bin_collection_week4(
+            txtBlack, txtBurgGreen, dtDay21, today, week4InSus
+        ):
+            # Check for empty values
+            if txtBlack == "" and txtBurgGreen == "":
+                return ""
+
+            # Black Bin Collection
+            if txtBlack == "" and dtDay21 >= today:
+                return "Black Bin"
+
+            # Burgundy Bin Collection (week4InSus check)
+            if txtBurgGreen == "1" and dtDay21 > today:
+                if week4InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week4InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            # Burgundy Bin Collection for txtBlack = '1'
+            if txtBlack == "1" and dtDay21 >= today:
+                if week4InSus == "Yes":
+                    return "Burgundy Bin"
+                elif week4InSus == "No":
+                    return "Burgundy Bin & Green Bin"
+
+            return ""  # Default empty case
+
+        week1Text = determine_bin_collection_week1(
+            WeekBlack, WeekBandG, week1, today, week1InSus
+        )
+        week2Text = determine_bin_collection_week2(
+            WeekBlack, WeekBandG, week2, today, week2InSus
+        )
+        week3Text = determine_bin_collection_week3(
+            WeekBlack, WeekBandG, week3, today, week3InSus
+        )
+        week4Text = determine_bin_collection_week4(
+            WeekBlack, WeekBandG, week4, today, week4InSus
+        )
+
+        # print(week1Text)
+        # print(week2Text)
+        # print(week3Text)
+        # print(week4Text)
+
+        week_data = [
+            (week1Text, week1),
+            (week2Text, week2),
+            (week3Text, week3),
+            (week4Text, week4),
+        ]
+
+        # print(week_data)
+
+        # Iterate through the array
+        for week_text, week_date in week_data:
+            # Check if '&' exists and split
+            if "&" in week_text:
+                split_texts = [text.strip() for text in week_text.split("&")]
+                for text in split_texts:
+                    dict_data = {
+                        "type": text,
+                        "collectionDate": week_date.strftime(date_format),
+                    }
+                    bindata["bins"].append(dict_data)
+            else:
+                dict_data = {
+                    "type": week_text,
+                    "collectionDate": week_date.strftime(date_format),
+                }
+                bindata["bins"].append(dict_data)
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/CherwellDistrictCouncil.py

@@ -0,0 +1,75 @@
+from datetime import datetime, timedelta
+
+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
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = f"https://www.cherwell.gov.uk/homepage/129/bin-collection-search?uprn={user_uprn}"
+
+        # Make the GET request
+        response = requests.get(URI)
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        def get_full_date(date_str):
+            # Get the current year
+            current_year = datetime.today().year
+
+            date_str = remove_ordinal_indicator_from_date_string(date_str)
+
+            # Convert the input string to a datetime object (assuming the current year first)
+            date_obj = datetime.strptime(f"{date_str} {current_year}", "%d %B %Y")
+
+            # If the date has already passed this year, use next year
+            if date_obj < datetime.today():
+                date_obj = datetime.strptime(
+                    f"{date_str} {current_year + 1}", "%d %B %Y"
+                )
+
+            return date_obj.strftime(date_format)  # Return in YYYY-MM-DD format
+
+        # print(soup)
+
+        div = soup.find("div", class_="bin-collection-results__tasks")
+
+        for item in div.find_all("li", class_="list__item"):
+            # Extract bin type
+            bin_type_tag = item.find("h3", class_="bin-collection-tasks__heading")
+            bin_type = (
+                "".join(bin_type_tag.find_all(text=True, recursive=False)).strip()
+                if bin_type_tag
+                else "Unknown Bin"
+            )
+
+            # Extract collection date
+            date_tag = item.find("p", class_="bin-collection-tasks__date")
+            collection_date = date_tag.text.strip() if date_tag else "Unknown Date"
+
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": get_full_date(collection_date),
+            }
+            bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/ConwyCountyBorough.py

@@ -1,12 +1,20 @@
+from datetime import datetime
+
+import requests
 from bs4 import BeautifulSoup
-from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
 from uk_bin_collection.uk_bin_collection.common import *
-from datetime import datetime
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
 
 
 class CouncilClass(AbstractGetBinDataClass):
     def parse_data(self, page: str, **kwargs) -> dict:
-        soup = BeautifulSoup(page.text, features="html.parser")
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        uri = f"https://www.conwy.gov.uk/Contensis-Forms/erf/collection-result-soap-xmas2025.asp?ilangid=1&uprn={user_uprn}"
+
+        response = requests.get(uri)
+        soup = BeautifulSoup(response.content, features="html.parser")
         data = {"bins": []}
 
         for bin_section in soup.select('div[class*="containererf"]'):

uk_bin_collection/uk_bin_collection/councils/CotswoldDistrictCouncil.py

@@ -41,15 +41,13 @@ class CouncilClass(AbstractGetBinDataClass):
             # If you bang in the house number (or property name) and postcode in the box it should find your property
             wait = WebDriverWait(driver, 60)
             address_entry_field = wait.until(
-                EC.presence_of_element_located(
-                    (By.XPATH, '//*[@id="combobox-input-20"]')
-                )
+                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-20"]'))
+                EC.element_to_be_clickable((By.XPATH, '//*[@id="combobox-input-22"]'))
             )
             address_entry_field.click()
             address_entry_field.send_keys(Keys.BACKSPACE)
@@ -57,7 +55,7 @@ class CouncilClass(AbstractGetBinDataClass):
 
             first_found_address = wait.until(
                 EC.element_to_be_clickable(
-                    (By.XPATH, '//*[@id="dropdown-element-20"]/ul')
+                    (By.XPATH, '//*[@id="dropdown-element-22"]/ul')
                 )
             )
 

uk_bin_collection/uk_bin_collection/councils/DerbyshireDalesDistrictCouncil.py

@@ -1,8 +1,5 @@
+import requests
 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
-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
@@ -19,63 +16,70 @@ class CouncilClass(AbstractGetBinDataClass):
     def parse_data(self, page: str, **kwargs) -> dict:
         driver = None
         try:
-            page = "https://selfserve.derbyshiredales.gov.uk/renderform.aspx?t=103&k=9644C066D2168A4C21BCDA351DA2642526359DFF"
+            uri = "https://selfserve.derbyshiredales.gov.uk/renderform.aspx?t=103&k=9644C066D2168A4C21BCDA351DA2642526359DFF"
 
-            data = {"bins": []}
+            bindata = {"bins": []}
 
             user_uprn = kwargs.get("uprn")
             user_postcode = kwargs.get("postcode")
-            web_driver = kwargs.get("web_driver")
-            headless = kwargs.get("headless")
             check_uprn(user_uprn)
             check_postcode(user_postcode)
 
-            # Create Selenium webdriver
-            driver = create_webdriver(web_driver, headless, None, __name__)
-            driver.get(page)
+            # Start a session
+            session = requests.Session()
 
-            # Populate postcode field
-            inputElement_postcode = driver.find_element(
-                By.ID,
-                "ctl00_ContentPlaceHolder1_FF2924TB",
-            )
-            inputElement_postcode.send_keys(user_postcode)
-
-            # Click search button
-            driver.find_element(
-                By.ID,
-                "ctl00_ContentPlaceHolder1_FF2924BTN",
-            ).click()
-
-            # Wait for the 'Select address' dropdown to appear and select option matching UPRN
-            dropdown = WebDriverWait(driver, 10).until(
-                EC.presence_of_element_located(
-                    (By.ID, "ctl00_ContentPlaceHolder1_FF2924DDL")
-                )
-            )
-            # Create a 'Select' for it, then select the matching URPN option
-            dropdownSelect = Select(dropdown)
-            dropdownSelect.select_by_value("U" + user_uprn)
-
-            # Wait for the submit button to appear, then click it to get the collection dates
-            submit = WebDriverWait(driver, 10).until(
-                EC.presence_of_element_located(
-                    (By.ID, "ctl00_ContentPlaceHolder1_btnSubmit")
-                )
-            )
-            submit.click()
+            response = session.get(uri)
 
-            soup = BeautifulSoup(driver.page_source, features="html.parser")
+            soup = BeautifulSoup(response.content, features="html.parser")
 
-            bin_rows = (
-                soup.find("div", id="ctl00_ContentPlaceHolder1_pnlConfirmation")
-                .find("div", {"class": "row"})
-                .find_all("div", {"class": "row"})
-            )
+            # Function to extract hidden input values
+            def get_hidden_value(soup, name):
+                element = soup.find("input", {"name": name})
+                return element["value"] if element else None
+
+            # Extract the required values
+            data = {
+                "__RequestVerificationToken": get_hidden_value(
+                    soup, "__RequestVerificationToken"
+                ),
+                "FormGuid": get_hidden_value(soup, "FormGuid"),
+                "ObjectTemplateID": get_hidden_value(soup, "ObjectTemplateID"),
+                "Trigger": "submit",
+                "CurrentSectionID": get_hidden_value(soup, "CurrentSectionID"),
+                "TriggerCtl": "",
+                "FF2924": "U" + user_uprn,
+                "FF2924lbltxt": "Collection address",
+                "FF2924-text": user_postcode,
+            }
+
+            # Print extracted data
+            # print("Extracted Data:", data)
+
+            # Step 2: Submit the extracted data via a POST request
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "Referer": uri,
+                "Content-Type": "application/x-www-form-urlencoded",
+            }
+
+            URI = "https://selfserve.derbyshiredales.gov.uk/renderform/Form"
+
+            # Make the POST request
+            post_response = session.post(URI, data=data, headers=headers)
+
+            soup = BeautifulSoup(post_response.content, features="html.parser")
+
+            # print(soup)
+
+            bin_rows = soup.find("div", {"class": "ss_confPanel"})
+
+            bin_rows = bin_rows.find_all("div", {"class": "row"})
             if bin_rows:
                 for bin_row in bin_rows:
                     bin_data = bin_row.find_all("div")
                     if bin_data and bin_data[0] and bin_data[1]:
+                        if bin_data[0].get_text(strip=True) == "Your Collections":
+                            continue
                         collection_date = datetime.strptime(
                             bin_data[0].get_text(strip=True), "%A%d %B, %Y"
                         )
@@ -83,9 +87,9 @@ class CouncilClass(AbstractGetBinDataClass):
                             "type": bin_data[1].get_text(strip=True),
                             "collectionDate": collection_date.strftime(date_format),
                         }
-                        data["bins"].append(dict_data)
+                        bindata["bins"].append(dict_data)
 
-            data["bins"].sort(
+            bindata["bins"].sort(
                 key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
             )
         except Exception as e:
@@ -97,4 +101,4 @@ class CouncilClass(AbstractGetBinDataClass):
             # This block ensures that the driver is closed regardless of an exception
             if driver:
                 driver.quit()
-        return data
+        return bindata

uk_bin_collection/uk_bin_collection/councils/EpsomandEwellBoroughCouncil.py

@@ -0,0 +1,86 @@
+from datetime import datetime, timedelta
+
+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
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = f"https://maps.epsom-ewell.gov.uk/myeebc.aspx?action=SetAddress&UniqueId={user_uprn}"
+
+        # Make the GET request
+        response = requests.get(URI)
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # print(soup)
+
+        div = soup.find_all("div", class_="atPanelContent atAlt1 atLast")
+
+        # print(div[1])
+
+        panels = div[1].find_all("div", class_="atPanelData")
+
+        # print(panels)
+
+        def get_full_date(date_str):
+            # Get the current year
+            current_year = datetime.today().year
+
+            # Convert the input string to a datetime object (assuming the current year first)
+            date_obj = datetime.strptime(f"{date_str} {current_year}", "%A %d %B %Y")
+
+            # If the date has already passed this year, use next year
+            if date_obj < datetime.today():
+                date_obj = datetime.strptime(
+                    f"{date_str} {current_year + 1}", "%A %d %B %Y"
+                )
+
+            return date_obj.strftime(date_format)  # Return in YYYY-MM-DD format
+
+        for panel in panels:
+            bin_type_tag = panel.find("h4")  # Extracts bin type
+            date_text = panel.find_all("td")  # Extracts collection date
+
+            date_text = date_text[1]
+
+            if bin_type_tag and date_text:
+                bin_type = bin_type_tag.text.strip()
+                try:
+                    collection_date = date_text.text.strip().split(":")[1]
+                except IndexError:
+                    continue
+
+                bin_type = (
+                    (" ".join(bin_type.splitlines())).replace("  ", " ")
+                ).lstrip()
+                collection_date = (
+                    (" ".join(collection_date.splitlines())).replace("  ", " ")
+                ).lstrip()
+
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": get_full_date(collection_date),
+                }
+                bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/GloucesterCityCouncil.py

@@ -113,7 +113,7 @@ class CouncilClass(AbstractGetBinDataClass):
                 bin_data["bins"].append(dict_data)
 
             bin_data["bins"].sort(
-                key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+                key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
             )
 
         except Exception as e:

uk_bin_collection/uk_bin_collection/councils/LeedsCityCouncil.py

@@ -104,7 +104,8 @@ class CouncilClass(AbstractGetBinDataClass):
             bin_types = soup.find_all("ul", class_="binCollectionTimesList")
 
             for bin_collection_dates in bin_types:
-                bin_collection_list = bin_collection_dates.find_all("li", class_="")
+
+                bin_collection_list = bin_collection_dates.find_all("li")
 
                 if bin_collection_list:
                     collection_dates = [