uk_bin_collection 0.74.0__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/CalderdaleCouncil.py

@@ -0,0 +1,123 @@
+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
+
+# This script pulls (in one hit) the data from Bromley Council Bins Data
+import datetime
+from bs4 import BeautifulSoup
+from datetime import datetime
+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 selenium.webdriver.common.keys import Keys
+import time
+
+
+# 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:
+        driver = None
+        try:
+            user_uprn = kwargs.get("uprn")
+            user_postcode = kwargs.get("postcode")
+            check_uprn(user_uprn)
+            check_postcode(user_postcode)
+
+            bin_data_dict = {"bins": []}
+            collections = []
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+
+            data = {"bins": []}
+
+            # Get our initial session running
+            driver = create_webdriver(web_driver, headless)
+            driver.get(kwargs.get("url"))
+
+            wait = WebDriverWait(driver, 30)
+            postcode = wait.until(
+                EC.presence_of_element_located((By.XPATH, '//*[@id="pPostcode"]'))
+            )
+
+            postcode.send_keys(user_postcode)
+            postcode_search_btn = wait.until(
+                EC.element_to_be_clickable((By.CLASS_NAME, "searchbox_submit"))
+            )
+            postcode_search_btn.send_keys(Keys.ENTER)
+            # Wait for the 'Select your property' dropdown to appear and select the first result
+            dropdown = wait.until(EC.element_to_be_clickable((By.ID, "uprn")))
+
+            # Create a 'Select' for it, then select the first address in the list
+            # (Index 0 is "Make a selection from the list")
+            dropdownSelect = Select(dropdown)
+            dropdownSelect.select_by_value(str(user_uprn))
+            checkbox = wait.until(EC.presence_of_element_located((By.ID, "gdprTerms")))
+            checkbox.send_keys(Keys.SPACE)
+            get_bin_data_btn = wait.until(
+                EC.element_to_be_clickable((By.CLASS_NAME, "searchbox_submit"))
+            )
+            get_bin_data_btn.send_keys(Keys.ENTER)
+            # Make a BS4 object
+            results = wait.until(EC.presence_of_element_located((By.ID, "collection")))
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+            soup.prettify()
+
+            data = {"bins": []}
+
+            # Get collections
+            row_index = 0
+            for row in soup.find("table", {"id": "collection"}).find_all("tr"):
+                # Skip headers row
+                if row_index < 1:
+                    row_index += 1
+                    continue
+                else:
+                    # Get bin info
+                    bin_info = row.find_all("td")
+                    # Get the bin type
+                    bin_type = bin_info[0].find("strong").get_text(strip=True)
+                    # Get the collection date
+                    collection_date = ""
+                    for p in bin_info[2].find_all("p"):
+                        if "your next collection" in p.get_text(strip=True):
+                            collection_date = datetime.strptime(
+                                " ".join(
+                                    p.get_text(strip=True)
+                                    .replace("will be your next collection.", "")
+                                    .split()
+                                ),
+                                "%A %d %B %Y",
+                            )
+
+                    if collection_date != "":
+                        # Append the bin type and date to the data dict
+                        dict_data = {
+                            "type": bin_type,
+                            "collectionDate": collection_date.strftime(date_format),
+                        }
+                        data["bins"].append(dict_data)
+
+                    row_index += 1
+
+            data["bins"].sort(
+                key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
+            )
+        except Exception as e:
+            # Here you can log the exception if needed
+            print(f"An error occurred: {e}")
+            # 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

uk_bin_collection/uk_bin_collection/councils/CannockChaseDistrictCouncil.py

@@ -0,0 +1,65 @@
+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")
+        user_postcode = kwargs.get("postcode")
+        check_uprn(user_uprn)
+        check_postcode(user_postcode)
+
+        # Make SOAP Request
+        response = requests.post(
+            "https://ccdc.opendata.onl/DynamicCall.dll",
+            data="Method=CollectionDates&Postcode="
+            + user_postcode
+            + "&UPRN="
+            + user_uprn,
+            headers={
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Referer": "https://ccdc.opendata.onl/CCDC_WasteCollection",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+            },
+        )
+
+        # Make a BS4 object
+        soup = BeautifulSoup(response.text, "xml")
+        soup.prettify()
+
+        if (
+            soup.find("ErrorDescription")
+            and soup.find("ErrorDescription").get_text(strip=True)
+            == "No results returned"
+        ):
+            raise ValueError("No collection data found for provided Postcode & UPRN.")
+
+        data = {"bins": []}
+
+        collections = soup.find_all("Collection")
+
+        for i in range(len(collections)):
+            dict_data = {
+                "type": collections[i]
+                .Service.get_text()
+                .replace("Collection Service", "")
+                .strip(),
+                "collectionDate": datetime.strptime(
+                    collections[i].Date.get_text(), "%d/%m/%Y %H:%M:%S"
+                ).strftime(date_format),
+            }
+            data["bins"].append(dict_data)
+
+        data["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
+        )
+        return data

uk_bin_collection/uk_bin_collection/councils/CardiffCouncil.py

@@ -0,0 +1,172 @@
+# So this script is a little different to the others...
+# Essentially, it uses Cardiff Council's waste collection API to return collections for a UPRN by pretending
+# to be Google Chrome
+
+import datetime
+import json
+from datetime import datetime
+
+import requests
+from requests import auth
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+# Taken from
+# https://stackoverflow.com/questions/29931671/making-an-api-call-in-python-with-an-api-that-requires-a-bearer-token
+class BearerAuth(requests.auth.AuthBase):
+    def __init__(self, token):
+        self.token = token
+
+    def __call__(self, r):
+        r.headers["authorization"] = "Bearer " + self.token
+        return r
+
+
+def parse_token(text: str) -> str:
+    """
+    Parses the response text to find the JWT token, which will always be the longest item in the list (I think)
+        :param text: The response text from the server
+        :return: Only the JWT token, as a string
+    """
+    # You'd have thought I'd use something like etree for this, but that doesn't work so going for a hacky approach
+    xml_list = text.split('"')
+    bearer_token = max(xml_list, key=len)
+    return bearer_token
+
+
+def get_jwt() -> str:
+    """
+    Gets a JSON web token from the authentication server
+        :return: A JWT token as a string
+    """
+    auth_url = (
+        "https://authwebservice.cardiff.gov.uk/AuthenticationWebService.asmx?op=GetJWT"
+    )
+    options_headers_str = (
+        "Accept: */*|Accept-Encoding: gzip, "
+        "deflate, br|Accept-Language: en-GB,en;q=0.9|Access-Control-Request-Headers: content-type"
+        "|Access-Control-Request-Method: POST|Connection: keep-alive|Host: "
+        "authwebservice.cardiff.gov.uk|Origin: https://www.cardiff.gov.uk|Referer: "
+        "https://www.cardiff.gov.uk/|Sec-Fetch-Dest: empty"
+        "|Sec-Fetch-Mode: cors|Sec-Fetch-Site: same-site|User-Agent: Mozilla/5.0 (Windows NT 10.0; "
+        "Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.134 Safari/537.36 "
+    )
+
+    request_headers_str = (
+        "Accept: */*|Accept-Encoding: gzip, deflate, br|Accept-Language: en-GB,en;q=0.9|Connection: "
+        'keep-alive|Content-Length: 284|Content-Type: text/xml; charset="UTF-8"|Host: '
+        "authwebservice.cardiff.gov.uk|Origin: https://www.cardiff.gov.uk|Referer: "
+        "https://www.cardiff.gov.uk/|Sec-Fetch-Dest: empty|Sec-Fetch-Mode: cors|Sec-Fetch-Site: "
+        "same-site|Sec-GPC: 1|User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.134 Safari/537.36 "
+    )
+
+    payload = (
+        "<?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><GetJWT xmlns='http://tempuri.org/' "
+        "/></soap:Body></soap:Envelope> "
+    )
+
+    options_headers = parse_header(options_headers_str)
+    request_headers = parse_header(request_headers_str)
+    try:
+        requests.packages.urllib3.disable_warnings()
+        options = requests.options(auth_url, headers=options_headers)
+        response = requests.post(auth_url, headers=request_headers, data=payload)
+        if not options.ok or not response.ok:
+            raise ValueError("Invalid server response code getting JWT!")
+
+    except Exception as ex:
+        print(f"Exception encountered: {ex}")
+        exit(1)
+    token = parse_token(response.text)
+    options.close()
+    response.close()
+
+    return token
+
+
+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:
+        """
+        Parse council provided CSVs to get the latest bin collections for address
+        """
+        # Change this
+        uprn = kwargs.get("uprn")
+        check_uprn(uprn)
+
+        data = {"bins": []}
+        token = get_jwt()
+
+        api_url = "https://api.cardiff.gov.uk/WasteManagement/api/WasteCollection"
+        options_header_str = (
+            "Accept: */*|Accept-Encoding: gzip, deflate, br|Accept-Language: en-GB,"
+            "en;q=0.9|Access-Control-Request-Headers: authorization,"
+            "content-type|Access-Control-Request-Method: POST|Connection: keep-alive|Host: "
+            "api.cardiff.gov.uk|Origin: https://www.cardiff.gov.uk|Referer: "
+            "https://www.cardiff.gov.uk/|Sec-Fetch-Dest: empty|Sec-Fetch-Mode: cors|Sec-Fetch-Site: "
+            "same-site|User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ("
+            "KHTML, like Gecko) Chrome/103.0.5060.134 Safari/537.36 "
+        )
+        response_header_str = (
+            "Accept: application/json, text/javascript, */*; q=0.01|Accept-Encoding: gzip, deflate, "
+            f"br|Accept-Language: en-GB,en;q=0.9|Authorization: {token}|Connection: "
+            "keep-alive|Content-Length: 62|Content-Type: application/json; charset=UTF-8|Host: "
+            "api.cardiff.gov.uk|Origin: https://www.cardiff.gov.uk|Referer: "
+            "https://www.cardiff.gov.uk/|Sec-Fetch-Dest: empty|Sec-Fetch-Mode: cors|Sec-Fetch-Site: "
+            "same-site|Sec-GPC: 1|User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.134 Safari/537.36 "
+        )
+
+        payload = (
+            '{ "systemReference": "web", "language": "eng", ' f'"uprn": {uprn} ' "}"
+        )
+
+        options_header = parse_header(options_header_str)
+        response_header = parse_header(response_header_str)
+        # Copy the request headers for options and post headers (replacing post auth with token variable) and post
+        # payload, then add here
+        try:
+            requests.packages.urllib3.disable_warnings()
+            options = requests.options(api_url, headers=options_header)
+            response = requests.post(
+                api_url, headers=response_header, auth=BearerAuth(token), data=payload
+            )
+            if not options.ok or not response.ok:
+                raise ValueError("Invalid server response code finding UPRN!")
+
+        except Exception as ex:
+            print(f"Exception encountered: {ex}")
+            exit(1)
+
+        result = json.loads(response.text)
+
+        options.close()
+        response.close()
+
+        collections = result["collectionWeeks"]
+        for week in collections:
+            collection = [(k, v) for k, v in week.items()]
+            collection_date = collection[1][1]
+            collection_date = datetime.strptime(
+                collection_date, "%Y-%m-%dT%H:%M:%S"
+            ).strftime(date_format)
+
+            for bin in collection[3][1]:
+                bin_type = bin.get("type")
+
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": collection_date,
+                }
+                data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/CastlepointDistrictCouncil.py

@@ -0,0 +1,96 @@
+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:
+        # Disable the SSL warnings that otherwise break everything
+        requests.packages.urllib3.disable_warnings()
+        try:
+            requests.packages.urllib3.contrib.pyopenssl.util.ssl_.DEFAULT_CIPHERS += (
+                ":HIGH:!DH:!aNULL"
+            )
+        except AttributeError:
+            pass
+
+        # UPRN is street id here
+        uprn = kwargs.get("uprn")
+        check_uprn(uprn)
+
+        post_url = "https://apps.castlepoint.gov.uk/cpapps/index.cfm?fa=wastecalendar.displayDetails"
+        post_header_str = (
+            "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,"
+            "image/apng,"
+            "*/*;q=0.8,application/signed-exchange;v=b3;q=0.9|Accept-Encoding: gzip, deflate, "
+            "br|Accept-Language: en-GB;q=0.8|Cache-Control: max-age=0|Connection: "
+            "keep-alive|Content-Length: "
+            "11|Content-Type: application/x-www-form-urlencoded|Host: apps.castlepoint.gov.uk|Origin: "
+            "https://apps.castlepoint.gov.uk|Referer: "
+            "https://apps.castlepoint.gov.uk/cpapps/index.cfm?fa=wastecalendar|Sec-Fetch-Dest: "
+            "document|Sec-Fetch-Mode: navigate|Sec-Fetch-Site: same-origin|Sec-Fetch-User: ?1|Sec-GPC: "
+            "1|Upgrade-Insecure-Requests: 1|User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.134 Safari/537.36 "
+        )
+
+        post_headers = parse_header(post_header_str)
+        form_data = {"roadID": uprn}
+        post_response = requests.post(
+            post_url, headers=post_headers, data=form_data, verify=False
+        )
+
+        # Make a BS4 object
+        soup = BeautifulSoup(post_response.text, features="html.parser")
+        soup.prettify()
+
+        data = {"bins": []}
+        collection_tuple = []
+
+        for i in range(1, 3):
+            calendar = soup.select(
+                f"#wasteCalendarContainer > div:nth-child(2) > div:nth-child({i}) > div"
+            )[0]
+            month = datetime.strptime(
+                calendar.find_next("h2").get_text(), "%B %Y"
+            ).strftime("%m")
+            year = datetime.strptime(
+                calendar.find_next("h2").get_text(), "%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))
+
+        ordered_data = sorted(collection_tuple, key=lambda x: x[1])
+
+        for item in ordered_data:
+            dict_data = {
+                "type": item[0],
+                "collectionDate": item[1].strftime(date_format),
+            }
+            data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/CharnwoodBoroughCouncil.py

@@ -0,0 +1,54 @@
+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
+
+from datetime import timedelta
+from dateutil.relativedelta import relativedelta
+
+
+# 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
+        soup = BeautifulSoup(page.text, features="html.parser")
+        soup.prettify()
+
+        data = {"bins": []}
+        curr_date = datetime.today()
+
+        for bins in soup.find_all("ul", {"class": "refuse"}):
+            binCollection = bins.find_all("li")
+
+            if binCollection:
+                for bin in binCollection:
+                    collection_date = (
+                        bin.find("strong", {"class": "date"}).contents[0].strip()
+                    )
+                    if collection_date.lower() == "today":
+                        collection_date = datetime.now()
+                    elif collection_date.lower() == "tomorrow":
+                        collection_date = datetime.now() + timedelta(days=1)
+                    else:
+                        collection_date += f" {curr_date.year}"
+                        collection_date = datetime.strptime(
+                            remove_ordinal_indicator_from_date_string(
+                                collection_date
+                            ).strip(),
+                            "%a %d %b %Y",
+                        )
+                        if curr_date.month == 12 and collection_date.month == 1:
+                            collection_date = collection_date + relativedelta(years=1)
+                    dict_data = {
+                        "type": bin.find("a").contents[0],
+                        "collectionDate": collection_date.strftime(date_format),
+                    }
+
+                    data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/ChelmsfordCityCouncil.py

@@ -0,0 +1,127 @@
+import re
+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
+
+# This script pulls (in one hit) the data from Bromley Council Bins Data
+import datetime
+from datetime import datetime
+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 selenium.webdriver.common.keys import Keys
+import time
+
+
+# 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:
+        driver = None
+        try:
+            data = {"bins": []}
+            headers = {"User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64)"}
+
+            uprn = kwargs.get("uprn")
+            postcode = kwargs.get("postcode")
+            user_paon = kwargs.get("paon")
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+            driver = create_webdriver(web_driver, headless)
+            url = kwargs.get("url")
+
+            driver.execute_script(f"window.location.href='{url}'")
+
+            wait = WebDriverWait(driver, 120)
+            post_code_search = wait.until(
+                EC.presence_of_element_located((By.XPATH, '//input[@name="keyword"]'))
+            )
+
+            post_code_search.send_keys(postcode)
+
+            submit_btn = wait.until(
+                EC.presence_of_element_located((By.CLASS_NAME, "__submitButton"))
+            )
+
+            submit_btn.send_keys(Keys.ENTER)
+
+            address_results = wait.until(
+                EC.presence_of_element_located((By.CLASS_NAME, "directories-table"))
+            )
+            address_link = wait.until(
+                EC.presence_of_element_located(
+                    (By.XPATH, f"//a[contains(text(), '{user_paon}')]")
+                )
+            )
+
+            address_link.send_keys(Keys.ENTER)
+            results = wait.until(
+                EC.presence_of_element_located((By.CLASS_NAME, "usercontent"))
+            )
+
+            # Make a BS4 object
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+            soup.prettify()
+
+            # Get collection calendar
+            calendar_urls = soup.find_all(
+                "a", string=re.compile(r"view or download the collection calendar")
+            )
+            if len(calendar_urls) > 0:
+                requests.packages.urllib3.disable_warnings()
+                response = requests.get(calendar_urls[0].get("href"), headers=headers)
+
+                # Make a BS4 object
+                soup = BeautifulSoup(response.text, features="html.parser")
+                soup.prettify()
+
+                # Loop the months
+                for month in soup.find_all("div", {"class": "usercontent"}):
+                    year = ""
+                    if month.find("h2") and "calendar" not in month.find("h2").get_text(
+                        strip=True
+                    ):
+                        year = datetime.strptime(
+                            month.find("h2").get_text(strip=True), "%B %Y"
+                        ).strftime("%Y")
+                    elif month.find("h3"):
+                        year = datetime.strptime(
+                            month.find("h3").get_text(strip=True), "%B %Y"
+                        ).strftime("%Y")
+                    if year != "":
+                        for row in month.find_all("li"):
+                            results = re.search(
+                                "([A-Za-z]+ \\d\\d? [A-Za-z]+): (.+)",
+                                row.get_text(strip=True),
+                            )
+                            if results:
+                                dict_data = {
+                                    "type": results.groups()[1].capitalize(),
+                                    "collectionDate": datetime.strptime(
+                                        results.groups()[0] + " " + year, "%A %d %B %Y"
+                                    ).strftime(date_format),
+                                }
+                                data["bins"].append(dict_data)
+
+                # Sort collections
+                data["bins"].sort(
+                    key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+                )
+        except Exception as e:
+            # Here you can log the exception if needed
+            print(f"An error occurred: {e}")
+            # 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

uk_bin_collection/uk_bin_collection/councils/CheshireEastCouncil.py

@@ -0,0 +1,32 @@
+from bs4 import BeautifulSoup
+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")
+
+        bin_data_dict = {"bins": []}
+
+        table = soup.find("table", {"class": "job-details"})
+        if table:
+            rows = table.find_all("tr", {"class": "data-row"})
+
+            for row in rows:
+                cells = row.find_all(
+                    "td", {"class": lambda L: L and L.startswith("visible-cell")}
+                )
+                labels = cells[0].find_all("label") if cells else []
+
+                if len(labels) >= 3:
+                    bin_type = labels[2].get_text(strip=True)
+                    collection_date = labels[1].get_text(strip=True)
+
+                    bin_data_dict["bins"].append(
+                        {
+                            "type": bin_type,
+                            "collectionDate": collection_date,
+                        }
+                    )
+
+        return bin_data_dict