uk_bin_collection 0.74.0__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/NorthNorfolkDistrictCouncil.py

@@ -0,0 +1,108 @@
+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
+
+
+# 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:
+            page = "https://forms.north-norfolk.gov.uk/outreach/BinCollectionDays.ofml"
+
+            data = {"bins": []}
+
+            user_paon = kwargs.get("paon")
+            user_postcode = kwargs.get("postcode")
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+            check_paon(user_paon)
+            check_postcode(user_postcode)
+
+            # Create Selenium webdriver
+            driver = create_webdriver(web_driver, headless)
+            driver.get(page)
+
+            # Populate postcode field
+            inputElement_postcode = driver.find_element(
+                By.ID,
+                "F_Address_subform:Postcode",
+            )
+            inputElement_postcode.send_keys(user_postcode)
+
+            # Click search button
+            driver.find_element(
+                By.ID,
+                "BA_Address_subform:Search_button",
+            ).click()
+
+            # Wait for the 'Select address' dropdown to appear
+            dropdown = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (By.XPATH, "//select[@id='F_Address_subform:Id']")
+                )
+            )
+            # Create a 'Select' for it, then select the matching house number/name option
+            dropdownSelect = Select(dropdown)
+            matchingOptions = [
+                o for o in dropdownSelect.options if user_paon.lower() in o.text.lower()
+            ]
+            if matchingOptions:
+                matchingOptions[0].click()
+
+                # Wait for the results to appear
+                WebDriverWait(driver, 10).until(
+                    EC.presence_of_element_located(
+                        (By.XPATH, "//div[contains(@class, 'fieldmergedcolumn')]/ul")
+                    )
+                )
+
+                soup = BeautifulSoup(driver.page_source, features="html.parser")
+
+                bins_text = soup.find("div", id="Search_result_details_cps_hd")
+
+                if bins_text:
+                    results = re.findall(
+                        "Your next (.*?) Bin collection is ([A-Za-z]+ \\d\\d? [A-Za-z]+)",
+                        bins_text.get_text(),
+                    )
+                    if results:
+                        for result in results:
+                            collection_date = datetime.strptime(
+                                result[1] + " " + datetime.now().strftime("%Y"),
+                                "%A %d %B %Y",
+                            )
+                            dict_data = {
+                                "type": result[0],
+                                "collectionDate": collection_date.strftime(date_format),
+                            }
+                            data["bins"].append(dict_data)
+
+                            data["bins"].sort(
+                                key=lambda x: datetime.strptime(
+                                    x.get("collectionDate"), date_format
+                                )
+                            )
+            else:
+                raise ValueError("No matching address for house number/name found.")
+        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/NorthNorthamptonshireCouncil.py

@@ -0,0 +1,72 @@
+import hashlib
+import math
+import time
+from datetime import datetime as dtm, timedelta
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+def myFunc(e):
+    return e["start"]
+
+
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+        data = {"bins": []}
+        uprn = kwargs.get("uprn")
+        check_uprn(uprn)
+        today = int(datetime.now().timestamp()) * 1000
+        dateforurl = datetime.now().strftime("%Y-%m-%d")
+        dateforurl2 = (datetime.now() + timedelta(days=42)).strftime("%Y-%m-%d")
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64)",
+        }
+        requests.packages.urllib3.disable_warnings()
+
+        # Get variables for workings
+        response = requests.get(
+            f"https://cms.northnorthants.gov.uk/bin-collection-search/calendarevents/{uprn}/{dateforurl}/{dateforurl2}",
+            headers=headers,
+        )
+        if response.status_code != 200:
+            raise ValueError("No bin data found for provided UPRN..")
+
+        json_response = json.loads(response.text)
+
+        output_dict = [
+            x
+            for x in json_response
+            if int("".join(filter(str.isdigit, x["start"]))) >= today
+        ]
+
+        output_json = output_dict
+        output_json.sort(key=myFunc)
+
+        i = 0
+        while i < len(output_json):
+            sov = output_json[i]["title"].lower()
+            if "recycling" in sov:
+                bin_type = "Recycling"
+            elif "garden" in sov:
+                bin_type = "Garden"
+            elif "refuse" in sov:
+                bin_type = "General"
+            else:
+                bin_type = "Unknown"
+            dateofbin = int("".join(filter(str.isdigit, output_json[i]["start"])))
+            day = dtm.fromtimestamp(dateofbin / 1000)
+            collection_data = {
+                "type": bin_type,
+                "collectionDate": day.strftime(date_format),
+            }
+            data["bins"].append(collection_data)
+            i += 1
+
+        return data

uk_bin_collection/uk_bin_collection/councils/NorthSomersetCouncil.py

@@ -0,0 +1,76 @@
+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
+
+
+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:
+        api_url = "https://forms.n-somerset.gov.uk/Waste/CollectionSchedule"
+        uprn = kwargs.get("uprn")
+        postcode = kwargs.get("postcode")
+        check_uprn(uprn)
+        check_postcode(postcode)
+
+        # Get schedule from API
+        values = {
+            "PreviousHouse": "",
+            "PreviousPostcode": postcode,
+            "Postcode": postcode,
+            "SelectedUprn": uprn,
+        }
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64)"}
+        requests.packages.urllib3.disable_warnings()
+        response = requests.request("POST", api_url, headers=headers, data=values)
+
+        soup = BeautifulSoup(response.text, features="html.parser")
+
+        rows = soup.find("table", {"class": re.compile("table")}).find_all("tr")
+
+        # Form a JSON wrapper
+        data = {"bins": []}
+
+        # Loops the Rows
+        for row in rows:
+            cells = row.find_all("td")
+            if cells:
+                binType = cells[0].get_text(strip=True)
+                collectionDate = (
+                    cells[1].get_text(strip=True) + " " + datetime.now().strftime("%Y")
+                )
+                nextCollectionDate = (
+                    cells[2].get_text(strip=True) + " " + datetime.now().strftime("%Y")
+                )
+
+                # Make each Bin element in the JSON
+                dict_data = {
+                    "type": binType,
+                    "collectionDate": get_next_occurrence_from_day_month(
+                        datetime.strptime(collectionDate, "%A %d %B %Y")
+                    ).strftime(date_format),
+                }
+
+                # Add data to the main JSON Wrapper
+                data["bins"].append(dict_data)
+
+                # Make each next Bin element in the JSON
+                dict_data = {
+                    "type": binType,
+                    "collectionDate": get_next_occurrence_from_day_month(
+                        datetime.strptime(nextCollectionDate, "%A %d %B %Y")
+                    ).strftime(date_format),
+                }
+
+                # Add data to the main JSON Wrapper
+                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/NorthTynesideCouncil.py

@@ -0,0 +1,220 @@
+import math
+from datetime import *
+
+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:
+        requests.packages.urllib3.disable_warnings()
+        data = {"bins": []}
+        user_uprn = kwargs.get("uprn")
+        user_postcode = kwargs.get("postcode")
+        check_uprn(user_uprn)
+        check_postcode(user_postcode)
+
+        # Get form data
+        s = requests.session()
+        cookies = {
+            "ntc-cookie-policy": "1",
+            "SSESS6ec6d5d2d471c0357053d5993a839bce": "qBdR7XhmSMd5_PDBIqG0It2R0Fq67igrejRY-WOcskE",
+            "has_js": "1",
+        }
+        headers = {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+            "Accept-Language": "en-GB,en;q=0.7",
+            "Cache-Control": "max-age=0",
+            "Connection": "keep-alive",
+            "Origin": "https://my.northtyneside.gov.uk",
+            "Referer": "https://my.northtyneside.gov.uk/category/81/bin-collection-dates",
+            "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/108.0.0.0 Safari/537.36",
+            "sec-ch-ua": '"Not?A_Brand";v="8", "Chromium";v="108", "Brave";v="108"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+        }
+        ajax_data = {
+            "postcode": user_postcode,
+            "form_build_id": "form-BQ47tM0NKADE0s8toYkdSef3QBn6lDM-yBseqIOho80",
+            "form_id": "ntc_address_wizard",
+            "_triggering_element_name": "op",
+            "_triggering_element_value": "Find",
+            "ajax_html_ids[]": [
+                "ntc-web-my",
+                "skip-link",
+                "navbar",
+                "navbar-collapse",
+                "search-block-form",
+                "ntc-web-search-input-label",
+                "ntc-web-search-input",
+                "ui-id-1",
+                "ntc-web-main",
+                "main-content",
+                "block-system-main",
+                "web-drupal-content",
+                "web-drupal-content-main",
+                "node-4024",
+                "block-ntc-address-ntc-address-finder",
+                "wizard-form-wrapper",
+                "ntc-address-wizard",
+                "edit-postcode",
+                "edit-find",
+                "backtotop",
+            ],
+            "ajax_page_state[theme]": "ntc_bootstrap",
+            "ajax_page_state[theme_token]": "LN05JIzI6rocWDiBpDyVeywYveuS4jlxD_N0_hhp2Ko",
+            "ajax_page_state[css][0]": "1",
+            "ajax_page_state[css][modules/system/system.base.css]": "1",
+            "ajax_page_state[css][misc/ui/jquery.ui.core.css]": "1",
+            "ajax_page_state[css][misc/ui/jquery.ui.theme.css]": "1",
+            "ajax_page_state[css][misc/ui/jquery.ui.menu.css]": "1",
+            "ajax_page_state[css][misc/ui/jquery.ui.autocomplete.css]": "1",
+            "ajax_page_state[css][sites/all/modules/calendar/css/calendar_multiday.css]": "1",
+            "ajax_page_state[css][sites/all/modules/date/date_repeat_field/date_repeat_field.css]": "1",
+            "ajax_page_state[css][modules/field/theme/field.css]": "1",
+            "ajax_page_state[css][modules/node/node.css]": "1",
+            "ajax_page_state[css][sites/all/modules/youtube/css/youtube.css]": "1",
+            "ajax_page_state[css][sites/all/modules/views/css/views.css]": "1",
+            "ajax_page_state[css][sites/all/modules/back_to_top/css/back_to_top.css]": "1",
+            "ajax_page_state[css][sites/all/modules/ckeditor/css/ckeditor.css]": "1",
+            "ajax_page_state[css][sites/all/modules/ctools/css/ctools.css]": "1",
+            "ajax_page_state[css][sites/all/modules/panels/css/panels.css]": "1",
+            "ajax_page_state[css][sites/all/modules/taxonomy_access/taxonomy_access.css]": "1",
+            "ajax_page_state[css][sites/all/modules/search_autocomplete/css/themes/minimal.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/bootstrap.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/generic.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/custom.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/components.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/modules.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/fostering.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/responsive.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/ie10.css]": "1",
+            "ajax_page_state[css][sites/all/themes/ntc_bootstrap/css/ie.css]": "1",
+            "ajax_page_state[js][0]": "1",
+            "ajax_page_state[js][1]": "1",
+            "ajax_page_state[js][sites/all/themes/bootstrap/js/bootstrap.js]": "1",
+            "ajax_page_state[js][//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js]": "1",
+            "ajax_page_state[js][misc/jquery-extend-3.4.0.js]": "1",
+            "ajax_page_state[js][misc/jquery-html-prefilter-3.5.0-backport.js]": "1",
+            "ajax_page_state[js][misc/jquery.once.js]": "1",
+            "ajax_page_state[js][misc/drupal.js]": "1",
+            "ajax_page_state[js][//ajax.googleapis.com/ajax/libs/jqueryui/1.10.2/jquery-ui.min.js]": "1",
+            "ajax_page_state[js][sites/all/modules/jquery_update/replace/ui/external/jquery.cookie.js]": "1",
+            "ajax_page_state[js][sites/all/modules/jquery_update/replace/misc/jquery.form.min.js]": "1",
+            "ajax_page_state[js][misc/ajax.js]": "1",
+            "ajax_page_state[js][sites/all/modules/jquery_update/js/jquery_update.js]": "1",
+            "ajax_page_state[js][sites/all/modules/back_to_top/js/back_to_top.js]": "1",
+            "ajax_page_state[js][sites/all/themes/bootstrap/js/misc/_progress.js]": "1",
+            "ajax_page_state[js][sites/all/modules/field_group/field_group.js]": "1",
+            "ajax_page_state[js][sites/all/modules/search_autocomplete/js/jquery.autocomplete.js]": "1",
+            "ajax_page_state[js][sites/all/themes/ntc_bootstrap/scripts/NTC.jquery.contentMenuScroller.js]": "1",
+            "ajax_page_state[js][sites/all/themes/ntc_bootstrap/scripts/NTC.jquery.alertClose.js]": "1",
+            "ajax_page_state[js][sites/all/themes/ntc_bootstrap/scripts/NTC.jquery.activeTrail.js]": "1",
+            "ajax_page_state[js][sites/all/themes/ntc_bootstrap/scripts/NTC.jquery.expandLinkToDiv.js]": "1",
+            "ajax_page_state[js][sites/all/themes/ntc_bootstrap/scripts/NTC.jquery.events.js]": "1",
+            "ajax_page_state[js][sites/all/themes/ntc_bootstrap/scripts/cookieconsent.js]": "1",
+            "ajax_page_state[js][sites/all/themes/ntc_bootstrap/scripts/google-analytics.js]": "1",
+            "ajax_page_state[js][sites/all/themes/ntc_bootstrap/scripts/ios-orientationchange-fix.js]": "1",
+            "ajax_page_state[js][sites/all/themes/bootstrap/js/misc/ajax.js]": "1",
+            "ajax_page_state[jquery_version]": "1.10",
+        }
+        uprn_data = {
+            "house_number": "0000" + f"{user_uprn}",
+            "op": "Use",
+            "form_build_id": "form-BQ47tM0NKADE0s8toYkdSef3QBn6lDM-yBseqIOho80",
+            "form_id": "ntc_address_wizard",
+        }
+        collections = []
+
+        response = s.post(
+            "https://my.northtyneside.gov.uk/system/ajax",
+            # cookies=cookies,
+            headers=headers,
+            data=ajax_data,
+            verify=False,
+        )
+        response = s.post(
+            "https://my.northtyneside.gov.uk/category/81/bin-collection-dates",
+            # cookies=cookies,
+            headers=headers,
+            data=uprn_data,
+            verify=False,
+        )
+        response = s.get(
+            "https://my.northtyneside.gov.uk/category/81/bin-collection-dates",
+            # cookies=cookies,
+            headers=headers,
+            data=uprn_data,
+            verify=False,
+        )
+
+        # Parse form page and get the day of week text
+        soup = BeautifulSoup(response.text, features="html.parser")
+        soup.prettify()
+        bin_text = soup.find("section", {"class": "block block-ntc-bins clearfix"})
+        regular_text = bin_text.select("p:nth-child(2) > strong")[0].text.strip()
+        x = bin_text.select("p:nth-child(4) > strong")
+        if len(bin_text.select("p:nth-child(4) > strong")) == 1:
+            special_text = bin_text.select("p:nth-child(4) > strong")[0].text.strip()
+        else:
+            special_text = bin_text.select("p:nth-child(5) > strong")[0].text.strip()
+
+        # Since calendar only shows until end of March 2024, work out how many weeks that is
+        weeks_total = math.floor((datetime(2024, 4, 1) - datetime.now()).days / 7)
+
+        # Convert day text to series of dates using previous calculation
+        regular_collections = get_weekday_dates_in_period(
+            datetime.today(),
+            days_of_week.get(regular_text.capitalize()),
+            amount=weeks_total,
+        )
+        special_collections = get_weekday_dates_in_period(
+            datetime.today(), days_of_week.get(special_text.capitalize())
+        )
+
+        # Differentiate between regular and recycling bins
+        for item in regular_collections:
+            item_as_date = datetime.strptime(item, date_format)
+            # Check if holiday (calendar only has one day that's a holiday, and it's moved to the next day)
+            if is_holiday(item_as_date, Region.ENG):
+                item_as_date += timedelta(days=1)
+            # Use the isoweek number to separate collections - at the time of writing 11th Jan is week 2, which
+            # is for the grey bin
+            if (item_as_date.date().isocalendar()[1] % 2) == 0:
+                collections.append(("Regular bin (green)", item_as_date))
+
+            else:
+                collections.append(("Recycling bin (grey)", item_as_date))
+
+        # Add the special collection dates to the collection tuple
+        collections += [
+            ("Special collection (bookable)", datetime.strptime(item, date_format))
+            for item in special_collections
+        ]
+
+        # Sort the collections tuple by date, the add to dictionary and return
+        ordered_data = sorted(collections, key=lambda x: x[1])
+        data = {"bins": []}
+        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/NorthWestLeicestershire.py

@@ -0,0 +1,114 @@
+from bs4 import BeautifulSoup
+from datetime import datetime, timedelta
+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
+import re  # Import regular expressions
+
+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:
+        driver = None
+        try:
+            data = {"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
+            page = f"https://my.nwleics.gov.uk/my-property-finder?address={user_postcode}&go=1"
+
+            driver = create_webdriver(web_driver, headless)
+            driver.get(page)
+
+            # If you bang in the house number (or property name) and postcode in the box it should find your property
+
+            # iframe_presense = WebDriverWait(driver, 30).until(
+            #    EC.presence_of_element_located((By.ID, "fillform-frame-1"))
+            # )
+
+            # driver.switch_to.frame(iframe_presense)
+            wait = WebDriverWait(driver, 60)
+
+            address_link = wait.until(
+                EC.element_to_be_clickable(
+                    (By.XPATH, f'//a[contains(@href, "{user_uprn}")]')
+                )
+            )
+
+            address_link.click()
+
+            refuse_element = wait.until(
+                EC.presence_of_element_located(
+                    (By.XPATH, f'//h3[contains(text(), "Refuse Collection Dates")]')
+                )
+            )
+
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+
+            # Find the unordered list containing refuse collection details
+            refuse_list = soup.find("ul", class_="refuse")
+
+            current_year = datetime.now().year
+
+            if refuse_list:
+                # Iterate through list items within the unordered list
+                for li in refuse_list.find_all("li"):
+                    date = li.find(
+                        "strong", class_="date"
+                    ).text.strip()  # Extract the date
+                    waste_type = li.find("a").text.strip()  # Extract the waste type
+
+                    # Parse the date from the string
+                    # check for today and tomorrow
+                    if date.lower() == "today":
+                        parsed_date = datetime.now().date()
+                    elif date.lower() == "tomorrow":
+                        parsed_date = (datetime.now() + timedelta(days=1)).date()
+                    else:
+                        date = re.sub(r"(st|nd|rd|th)", "", date)
+                        parsed_date = datetime.strptime(date, "%a %d %b").date()
+
+                    current_date = datetime.now().date()
+
+                    # double check we've got a year and if not the current one
+                    if parsed_date.year < current_date.year:
+                        parsed_date = parsed_date.replace(year=current_date.year)
+
+                    # check if the date is in the past and if so add a year
+                    if parsed_date < current_date:
+                        parsed_date = parsed_date.replace(year=current_date.year + 1)
+
+                    # Append data to your 'bins' list (this replicates your existing logic)
+                    data["bins"].append(
+                        {
+                            "type": waste_type,
+                            "collectionDate": parsed_date.strftime("%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/NorthYorkshire.py

@@ -0,0 +1,58 @@
+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
+
+
+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:
+        uprn = kwargs.get("uprn")
+        check_uprn(uprn)
+
+        # Figure bin data URL from UPRN
+        url = "https://www.northyorks.gov.uk/bin-calendar/lookup"
+
+        payload = {
+            "selected_address": uprn,
+            "submit": "Continue",
+            "form_id": "bin_calendar_lookup_form",
+        }
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+        # This endpoint redirects to the data url.
+        response = requests.request("POST", url, headers=headers, data=payload)
+        bin_data_url = f"{response.url}/ajax"
+
+        # Get bin data
+        response = requests.request("GET", bin_data_url)
+        bin_data = response.json()
+
+        # Parse bin data
+        soup = BeautifulSoup(bin_data[1]["data"], "html.parser")
+
+        # All collection info is in the table
+        table = (
+            soup.find("div", {"id": "upcoming-collection"}).find("table").find("tbody")
+        )
+        rows = table.find_all("tr")
+
+        data = {"bins": []}
+        for row in rows:
+            cols = row.find_all("td")
+            # First column is date
+            bin_date = datetime.strptime(cols[0].text.strip(), "%d %B %Y")
+            # Third column is type
+            bin_type = cols[2].text.strip()
+            # This bin
+            this_bin = {
+                "type": bin_type,
+                "collectionDate": bin_date.strftime(date_format),
+            }
+            data["bins"].append(this_bin)
+
+        return data