uk_bin_collection 0.74.0__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/GlasgowCityCouncil.py

@@ -0,0 +1,55 @@
+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:
+        # Parse the page
+        soup = BeautifulSoup(page.text, features="html.parser")
+        soup.prettify()
+
+        # Declare an empty dict for data, and pair icon source URLs with their respective bin type
+        data = {"bins": []}
+        bin_types = {
+            "../images/bins/cal_blue.png": "Mixed recycling",
+            "../images/bins/cal_green.png": "General waste",
+            "../images/bins/cal_grey.png": "Food waste",
+            "../images/bins/cal_brown.png": "Organic waste",
+            "../images/bins/cal_purple.png": "Glass",
+            "../images/bins/cal_ash.png": "Ash bin",
+        }
+
+        # Find the page body with all the calendars
+        body = soup.find("div", {"id": "printArticle"})
+        cal_year = datetime.strptime(soup.select("#Year")[0].text.strip(), "%Y").year
+        calendars = body.find_all_next("table", {"title": "Calendar"})
+
+        # For each calendar grid, get the month and all icons within it. We only take icons with alt text, as this
+        # includes the bin type while excluding spacers
+        for item in calendars:
+            cal_month = datetime.strptime(item.find_next("td").text.strip(), "%B").month
+            icons = item.find_all("img", alt=True)
+
+            # For each icon, get the day box, so we can parse the correct day number and make a datetime
+            for icon in icons:
+                cal_item = icon.find_parent().find_parent().find_parent().contents
+                cal_day = datetime.strptime(cal_item[1].text.strip(), "%d").day
+                bin_date = datetime(cal_year, cal_month, cal_day)
+
+                # If the collection date is in the future, we want the date. Select the correct type, add the new
+                # datetime, then add to the list
+                if datetime.now() <= bin_date:
+                    dict_data = {
+                        "type": bin_types.get(icon["src"].lower()),
+                        "collectionDate": bin_date.strftime(date_format),
+                    }
+                    data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/GuildfordCouncil.py

@@ -0,0 +1,150 @@
+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:
+            uprn = kwargs.get("uprn")
+            postcode = kwargs.get("postcode")
+            full_address = kwargs.get("paon")
+
+            url = "https://my.guildford.gov.uk/customers/s/view-bin-collections"
+
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+
+            driver = create_webdriver(web_driver, headless)
+            driver.get(kwargs.get("url"))
+
+            wait = WebDriverWait(driver, 120)
+            post_code_search = wait.until(
+                EC.presence_of_element_located(
+                    (By.XPATH, "//input[contains(@class, 'slds-input')]")
+                )
+            )
+
+            post_code_search.send_keys(postcode)
+
+            post_code_submit_btn = wait.until(
+                EC.presence_of_element_located(
+                    (By.XPATH, "//button[contains(@class,'slds-button')]")
+                )
+            )
+            post_code_submit_btn.send_keys(Keys.ENTER)
+
+            # Locate the element containing the specified address text
+            address_element = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (
+                        By.XPATH,
+                        f"//lightning-base-formatted-text[contains(text(), '{full_address}')]",
+                    )
+                )
+            )
+
+            # Find the associated radio button in the same row (preceding sibling)
+            radio_button = address_element.find_element(
+                By.XPATH, "../../../../preceding-sibling::td//input[@type='radio']"
+            )
+
+            radio_button.send_keys(Keys.SPACE)
+            address_submit_btn = wait.until(
+                EC.presence_of_element_located(
+                    (By.XPATH, "//button[contains(@name,'NEXT')]")
+                )
+            )
+            address_submit_btn.send_keys(Keys.ENTER)
+
+            results = wait.until(
+                EC.presence_of_element_located((By.CLASS_NAME, "cBinScheduleDisplay"))
+            )
+
+            results2 = wait.until(
+                EC.presence_of_element_located(
+                    (By.XPATH, f'//div[contains(@title,"Bin Job")]')
+                )
+            )
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+            # Find all table rows containing bin information
+            rows = soup.find_all("tr", class_="slds-hint-parent")
+
+            data = {"bins": []}
+
+            # Extract bin type and next collection date for each row
+            for row in rows:
+                bin_type = (
+                    row.find("td", {"data-label": "Bin Job"})
+                    .find("strong")
+                    .text.strip()
+                    if row.find("td", {"data-label": "Bin Job"})
+                    else None
+                )
+
+                next_collection_date = (
+                    row.find("td", {"data-label": "Next Collection"}).text.strip()
+                    if row.find("td", {"data-label": "Next Collection"})
+                    else None
+                )
+
+                if bin_type and next_collection_date:
+                    # Convert date string to datetime object
+                    date_format = (
+                        "%A, %d %B"  # Adjust the format according to your date string
+                    )
+                    try:
+                        next_collection_date = datetime.strptime(
+                            next_collection_date, date_format
+                        )
+
+                        # Logic to determine year
+                        current_date = datetime.now()
+                        if next_collection_date.month < current_date.month:
+                            year = current_date.year + 1
+                        else:
+                            year = current_date.year
+
+                        # Format the date
+                        next_collection_date = next_collection_date.replace(
+                            year=year
+                        ).strftime("%d/%m/%Y")
+                    except ValueError:
+                        pass
+
+                    dict_data = {
+                        "type": bin_type,
+                        "collectionDate": next_collection_date,
+                    }
+                    data["bins"].append(dict_data)
+        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/HaltonBoroughCouncil.py

@@ -0,0 +1,142 @@
+from bs4 import BeautifulSoup
+from datetime import datetime
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import Select
+from selenium.webdriver.support.wait import WebDriverWait
+import time
+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_paon = kwargs.get("paon")
+            user_postcode = kwargs.get("postcode")
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+            # Create Selenium webdriver
+            page = (
+                f"https://webapp.halton.gov.uk/PublicWebForms/WasteServiceSearchv1.aspx"
+            )
+
+            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)
+
+            inputElement_property = wait.until(
+                EC.element_to_be_clickable(
+                    (By.NAME, "ctl00$ContentPlaceHolder1$txtProperty")
+                )
+            )
+            inputElement_property.send_keys(user_paon)
+
+            inputElement_postcodesearch = wait.until(
+                EC.element_to_be_clickable(
+                    (By.NAME, "ctl00$ContentPlaceHolder1$txtPostcode")
+                )
+            )
+            inputElement_postcodesearch.send_keys(user_postcode)
+            time.sleep(1)
+            wait.until(
+                EC.frame_to_be_available_and_switch_to_it(
+                    (
+                        By.CSS_SELECTOR,
+                        "iframe[name^='a-'][src^='https://www.google.com/recaptcha/api2/anchor?']",
+                    )
+                )
+            )
+            wait.until(
+                EC.element_to_be_clickable((By.XPATH, "//span[@id='recaptcha-anchor']"))
+            ).send_keys(Keys.ENTER)
+            time.sleep(5)
+            driver.switch_to.default_content()
+            search_btn = wait.until(
+                EC.element_to_be_clickable(
+                    (By.XPATH, '//*[@id="ContentPlaceHolder1_btnSearch"]')
+                )
+            )
+            search_btn.send_keys(Keys.ENTER)
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+
+            # Find all tab panels within the collectionTabs
+            # Find all anchor elements within the collectionTabs
+            anchor_elements = soup.select("#collectionTabs a.ui-tabs-anchor")
+
+            for anchor in anchor_elements:
+                # Extract the type of waste from the anchor text
+                waste_type = anchor.text.strip()
+
+                # Find the corresponding panel using the href attribute
+                panel_id = anchor.get("href")
+                panel = soup.select_one(panel_id)
+
+                # Find all ul elements within the corresponding panel
+                ul_elements = panel.find_all("ul")
+
+                # Check if there are at least two ul elements
+                if len(ul_elements) >= 2:
+                    # Get the second ul element and extract its li elements
+                    second_ul = ul_elements[1]
+                    li_elements = second_ul.find_all("li")
+
+                    # Extract the text content of each li element
+                    date_texts = [
+                        re.sub(r"[^a-zA-Z0-9,\s]", "", li.get_text(strip=True)).strip()
+                        for li in li_elements
+                    ]
+
+                    for date_text in date_texts:
+                        # Extracting dates from the text using simple text manipulation
+                        # Assuming the dates are in the format: "Friday 15th December 2023", "Friday 22nd December 2023", etc.
+                        # Parse the date string into a datetime object
+                        date_string_without_ordinal = re.sub(
+                            r"(\d+)(st|nd|rd|th)", r"\1", date_text
+                        )
+
+                        parsed_date = datetime.strptime(
+                            date_string_without_ordinal, "%A %d %B %Y"
+                        )
+
+                        # Format the datetime object into the desired format '%d/%m/%Y'
+                        formatted_date = parsed_date.strftime("%d/%m/%Y")
+
+                        # Add extracted data to the 'bins' list
+                        data["bins"].append(
+                            {
+                                "type": waste_type.capitalize(),
+                                "collectionDate": formatted_date,
+                            }
+                        )
+        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/HaringeyCouncil.py

@@ -0,0 +1,59 @@
+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:
+        data = {"bins": []}
+
+        uprn = kwargs.get("uprn")
+        check_uprn(uprn)  # Assuming check_uprn() raises an exception if UPRN is invalid
+
+        try:
+            response = requests.post(
+                f"https://wastecollections.haringey.gov.uk/property/{uprn}",
+                timeout=10,  # Set a timeout for the request
+            )
+            response.raise_for_status()  # This will raise an exception for HTTP errors
+        except requests.RequestException as e:
+            logging.error(f"Network or HTTP error occurred: {e}")
+            raise ConnectionError("Failed to retrieve data.") from e
+
+        try:
+            soup = BeautifulSoup(response.text, features="html.parser")
+            soup.prettify()
+
+            sections = soup.find_all("div", {"class": "property-service-wrapper"})
+
+            date_regex = re.compile(r"\d{2}/\d{2}/\d{4}")
+            for section in sections:
+                service_name_element = section.find("h3", {"class": "service-name"})
+                next_service_element = section.find("tbody").find(
+                    "td", {"class": "next-service"}
+                )
+
+                if service_name_element and next_service_element:
+                    service = service_name_element.text
+                    next_collection = next_service_element.find(text=date_regex)
+
+                    if next_collection:
+                        dict_data = {
+                            "type": service.replace("Collect ", "")
+                            .replace("Paid ", "")
+                            .strip(),
+                            "collectionDate": next_collection.strip(),
+                        }
+                        data["bins"].append(dict_data)
+        except Exception as e:
+            logging.error(f"Error parsing data: {e}")
+            raise ValueError("Error processing the HTML data.") from e
+
+        return data

uk_bin_collection/uk_bin_collection/councils/HarrogateBoroughCouncil.py

@@ -0,0 +1,63 @@
+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)
+
+        data = {"bins": []}
+
+        headers = {
+            "accept-language": "en-GB,en;q=0.9",
+            "cache-control": "no-cache",
+        }
+
+        req_data = {
+            "uprn": user_uprn,
+        }
+
+        url = f"https://secure.harrogate.gov.uk/inmyarea/Property/?uprn={user_uprn}"
+
+        requests.packages.urllib3.disable_warnings()
+        response = requests.post(url, headers=headers)
+
+        soup = BeautifulSoup(response.text, features="html.parser")
+        soup.prettify()
+
+        collections = []
+
+        # Find section with bins in
+        table = soup.find_all("table", {"class": "hbcRounds"})[1]
+
+        # For each bin section, get the text and the list elements
+        for row in table.find_all("tr"):
+            bin_type = row.find("th").text
+            td = row.find("td")
+            for span in td.find_all("span"):
+                span.extract()
+            collectionDate = td.text.strip()
+            next_collection = datetime.strptime(collectionDate, "%a %d %b %Y")
+            collections.append((bin_type, next_collection))
+
+        # Sort the text and list elements by date
+        ordered_data = sorted(collections, key=lambda x: x[1])
+
+        # Put the elements into the dictionary
+        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/HighPeakCouncil.py

@@ -0,0 +1,134 @@
+from bs4 import BeautifulSoup
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import Select
+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
+
+
+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 get_data(self, page) -> dict:
+        # Make a BS4 object
+        soup = BeautifulSoup(page, features="html.parser")
+        soup.prettify()
+
+        data = {"bins": []}
+
+        for month in soup.select('div[class*="bin-collection__month"]'):
+            monthName = month.select('h3[class*="bin-collection__title"]')[
+                0
+            ].text.strip()
+            for collectionDay in month.select('li[class*="bin-collection__item"]'):
+                bin_type = collectionDay.select('span[class*="bin-collection__type"]')[
+                    0
+                ].text.strip()
+                binCollection = (
+                    collectionDay.select('span[class*="bin-collection__day"]')[
+                        0
+                    ].text.strip()
+                    + ", "
+                    + collectionDay.select('span[class*="bin-collection__number"]')[
+                        0
+                    ].text.strip()
+                    + " "
+                    + monthName
+                )
+
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": datetime.strptime(
+                        binCollection, "%A, %d %B %Y"
+                    ).strftime(date_format),
+                }
+
+                data["bins"].append(dict_data)
+
+        return data
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+        driver = None
+        try:
+            page = "https://www.highpeak.gov.uk/findyourbinday"
+
+            # Assign user info
+            user_postcode = kwargs.get("postcode")
+            user_paon = kwargs.get("paon")
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+
+            # Create Selenium webdriver
+            driver = create_webdriver(web_driver, headless)
+            driver.get(page)
+
+            # Hide Cookies
+            inputElement_hc = driver.find_element(
+                By.CLASS_NAME, "cookiemessage__link--close"
+            )
+            inputElement_hc.click()
+
+            # Enter postcode in text box and wait
+            inputElement_pc = driver.find_element(
+                By.ID, "FINDBINDAYSHIGHPEAK_POSTCODESELECT_POSTCODE"
+            )
+            inputElement_pc.send_keys(user_postcode)
+            inputElement_pc.send_keys(Keys.ENTER)
+
+            WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (By.ID, "FINDBINDAYSHIGHPEAK_ADDRESSSELECT_ADDRESS")
+                )
+            )
+
+            # Select address from dropdown and wait
+            inputElement_ad = Select(
+                driver.find_element(By.ID, "FINDBINDAYSHIGHPEAK_ADDRESSSELECT_ADDRESS")
+            )
+
+            inputElement_ad.select_by_visible_text(user_paon)
+
+            WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (
+                        By.ID,
+                        "FINDBINDAYSHIGHPEAK_ADDRESSSELECT_ADDRESSSELECTNEXTBTN_NEXT",
+                    )
+                )
+            )
+
+            # Submit address information and wait
+            driver.find_element(
+                By.ID, "FINDBINDAYSHIGHPEAK_ADDRESSSELECT_ADDRESSSELECTNEXTBTN_NEXT"
+            ).click()
+
+            WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (By.ID, "FINDBINDAYSHIGHPEAK_CALENDAR_MAINCALENDAR")
+                )
+            )
+
+            # Read next collection information into Pandas
+            table = driver.find_element(
+                By.ID, "FINDBINDAYSHIGHPEAK_CALENDAR_MAINCALENDAR"
+            ).get_attribute("outerHTML")
+
+            # Parse data into dict
+            data = self.get_data(table)
+        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/HullCityCouncil.py

@@ -0,0 +1,48 @@
+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)
+        data = {"bins": []}
+
+        headers = {
+            "authority": "www.hull.gov.uk",
+            "accept": "*/*",
+            "accept-language": "en-GB,en;q=0.9",
+            "cache-control": "no-cache",
+            "pragma": "no-cache",
+            "referer": "https://www.hull.gov.uk/bins-and-recycling/bin-collections/bin-collection-day-checker",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.6167.186 Safari/537.36",
+        }
+        api_url = f"https://www.hull.gov.uk/ajax/bin-collection?bindate={user_uprn}"
+
+        res = requests.get(api_url, headers=headers)
+        if res.status_code != 200:
+            raise ConnectionRefusedError("Cannot connect to API!")
+
+        json_data = res.json()[0]
+        for item in json_data:
+            dict_data = {
+                "type": item.get("collection_type").capitalize(),
+                "collectionDate": datetime.strptime(
+                    item.get("next_collection_date"), "%Y-%m-%d"
+                ).strftime(date_format),
+            }
+            data["bins"].append(dict_data)
+
+        return data