uk_bin_collection 0.74.0__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/NorthumberlandCouncil.py

@@ -0,0 +1,123 @@
+import time
+from bs4 import BeautifulSoup
+from selenium.webdriver.common.by import By
+
+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 extract_styles(self, style_str: str) -> dict:
+        return dict(
+            (a.strip(), b.strip())
+            for a, b in (
+                element.split(":") for element in style_str.split(";") if element
+            )
+        )
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+        driver = None
+        try:
+            page = "https://www.northumberland.gov.uk/Waste/Bins/Bin-Calendars.aspx"
+
+            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)
+
+            time.sleep(1)
+
+            # Press the cookie accept - wait is to let the JS load it up
+            driver.find_element(By.ID, "ccc-notify-accept").click()
+
+            inputElement_hn = driver.find_element(
+                By.ID,
+                "p_lt_ctl04_pageplaceholder_p_lt_ctl02_WasteCollectionCalendars_NCCAddressLookup_txtHouse",
+            )
+            inputElement_pc = driver.find_element(
+                By.ID,
+                "p_lt_ctl04_pageplaceholder_p_lt_ctl02_WasteCollectionCalendars_NCCAddressLookup_txtPostcode",
+            )
+
+            inputElement_pc.send_keys(user_postcode)
+            inputElement_hn.send_keys(user_paon)
+
+            driver.find_element(
+                By.ID,
+                "p_lt_ctl04_pageplaceholder_p_lt_ctl02_WasteCollectionCalendars_NCCAddressLookup_butLookup",
+            ).click()
+
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+
+            # Work out which bins can be collected for this address. Glass bins are only on some houses due to pilot programme.
+            bins_collected = list(
+                map(
+                    str.strip,
+                    soup.find(
+                        "span",
+                        id="p_lt_ctl04_pageplaceholder_p_lt_ctl02_WasteCollectionCalendars_spanRouteSummary",
+                    )
+                    .string.replace("Routes found: ", "")
+                    .split(","),
+                )
+            )
+
+            # Get the background colour for each of them...
+            bins_by_colours = dict()
+            for bin in bins_collected:
+                style_str = soup.find("span", string=bin)["style"]
+                bin_colour = self.extract_styles(style_str)["background-color"].upper()
+                bins_by_colours[bin_colour] = bin
+
+            # Work through the tables gathering the dates, if the cell has a background colour - match it to the bin type.
+            calander_tables = soup.find_all("table", title="Calendar")
+            for table in calander_tables:
+                # Get month and year
+                # First row in table is the header
+                rows = table.find_all("tr")
+                month_and_year = (
+                    rows[0].find("table", class_="calCtrlTitle").find("td").string
+                )
+                bin_days = table.find_all("td", class_="calCtrlDay")
+                for day in bin_days:
+                    day_styles = self.extract_styles(day["style"])
+                    if "background-color" in day_styles:
+                        colour = day_styles["background-color"].upper()
+                        date = time.strptime(
+                            f"{day.string} {month_and_year}", "%d %B %Y"
+                        )
+
+                        # Add it to the data
+                        data["bins"].append(
+                            {
+                                "type": bins_by_colours[colour],
+                                "collectionDate": time.strftime(date_format, 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/NottinghamCityCouncil.py

@@ -0,0 +1,36 @@
+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:
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+
+        api_url = f"https://geoserver.nottinghamcity.gov.uk/myproperty/handler/proxy.ashx?https://geoserver.nottinghamcity.gov.uk/bincollections2/api/collection/{user_uprn}"
+
+        requests.packages.urllib3.disable_warnings()
+        response = requests.get(api_url)
+        json_data = json.loads(response.text)
+        data = {"bins": []}
+
+        next_collections = json_data["nextCollections"]
+
+        for collection in next_collections:
+            bin_type = collection["collectionType"]
+
+            next_collection_date = datetime.fromisoformat(collection["collectionDate"])
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": next_collection_date.strftime(date_format),
+            }
+            data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/OldhamCouncil.py

@@ -0,0 +1,51 @@
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+from bs4 import BeautifulSoup
+
+
+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": []}
+        soup = BeautifulSoup(page.text, "html.parser")
+
+        # Find all tables with the class "data-table confirmation"
+        tables = soup.find_all("table", class_="data-table confirmation")
+        for table in tables:
+            rows = table.find_all("tr")
+            bin_type = None
+            bin_collection = None
+
+            # Search for the bin color in the table headers
+            th_element = table.find("th")
+            if th_element:
+                bin_type = th_element.text.strip()
+
+            for row in rows:
+                header = row.find("b")
+                if header:
+                    header_text = header.text.strip()
+                    value_cell = row.find("td", class_="coltwo")
+                    if value_cell:
+                        value_text = value_cell.text.strip()
+
+                        if header_text == "Collection Date":
+                            bin_collection = value_text
+
+            if bin_type and bin_collection:
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": datetime.strptime(
+                        bin_collection, "%d/%m/%Y"
+                    ).strftime(date_format),
+                }
+
+                data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/PortsmouthCityCouncil.py

@@ -0,0 +1,131 @@
+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
+
+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:
+            page = "https://my.portsmouth.gov.uk/en/AchieveForms/?form_uri=sandbox-publish://AF-Process-26e27e70-f771-47b1-a34d-af276075cede/AF-Stage-cd7cc291-2e59-42cc-8c3f-1f93e132a2c9/definition.json&redirectlink=%2F&cancelRedirectLink=%2F"
+
+            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
+            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_postcodesearch = wait.until(
+                EC.element_to_be_clickable((By.NAME, "postcode_search"))
+            )
+
+            inputElement_postcodesearch.send_keys(user_postcode)
+            lookupAddress_btn = wait.until(
+                EC.element_to_be_clickable((By.ID, "lookupAddress"))
+            )
+
+            lookupAddress_btn.click()
+
+            # Wait for the 'Select your property' dropdown to appear and select the first result
+            dropdown = wait.until(
+                EC.element_to_be_clickable((By.NAME, "Choose_Address"))
+            )
+
+            dropdown_options = wait.until(
+                EC.presence_of_element_located((By.CLASS_NAME, "lookup-option"))
+            )
+            time.sleep(1)
+            # 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))
+
+            h4_element = wait.until(
+                EC.presence_of_element_located(
+                    (By.XPATH, "//h4[contains(text(), 'next 10 collection dates')]")
+                )
+            )
+
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+            # Define your XPath
+            elements_with_data_field_name = soup.find_all(
+                lambda tag: tag.has_attr("data-field-name")
+                and tag["data-field-name"].startswith("html")
+            )
+            if elements_with_data_field_name:
+                for element in elements_with_data_field_name:
+                    # Extract h4 text from the current element
+                    h4_text = (
+                        element.find("h4").get_text(strip=True)
+                        if element.find("h4")
+                        else None
+                    )
+
+                    # Process the data (dates) in the current element (p tags)
+
+                    if h4_text:
+                        if "next 10" in h4_text:
+                            data_paragraphs = element.find_all("p") if element else []
+
+                            # Extract dates from the first <p> tag (assuming dates are in the first <p> tag)
+                            dates_paragraph = (
+                                data_paragraphs[0] if len(data_paragraphs) > 0 else None
+                            )
+                            dates = (
+                                dates_paragraph.find_all(string=True, recursive=False)
+                                if dates_paragraph
+                                else []
+                            )
+
+                            for date in dates:
+                                data["bins"].append(
+                                    {
+                                        "type": h4_text.split(" - ")[0],
+                                        "collectionDate": datetime.strptime(
+                                            re.sub(
+                                                r"[^a-zA-Z0-9,\s]", "", date
+                                            ).strip(),
+                                            "%A %d %B %Y",
+                                        ).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/PrestonCityCouncil.py

@@ -0,0 +1,97 @@
+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 uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+from selenium.webdriver.common.keys import Keys
+
+
+# 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://selfservice.preston.gov.uk/service/Forms/FindMyNearest.aspx?Service=bins"
+
+            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)
+
+            # If you bang in the house number (or property name) and postcode in the box it should find your property
+            inputElement_address = driver.find_element(
+                By.ID,
+                "MainContent_txtAddress",
+            )
+
+            inputElement_address.send_keys(user_paon)
+            inputElement_address.send_keys(" ")
+            inputElement_address.send_keys(user_postcode)
+
+            driver.find_element(
+                By.ID,
+                "btnSearch",
+            ).send_keys(Keys.ENTER)
+
+            # Wait for the 'Select your property' dropdown to appear and select the first result
+            dropdown = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located((By.ID, "MainContent_ddlSearchResults"))
+            )
+            # 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_index(1)
+
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+
+            topLevelSpan = soup.find("span", id="MainContent_lblMoreCollectionDates")
+
+            collectionDivs = topLevelSpan.find_all("div", {"id": "container"})
+
+            for collectionDiv in collectionDivs:
+                type_and_date_divs = collectionDiv.find_all("b")
+                bin_type = type_and_date_divs[0].text
+
+                date_elements = collectionDiv.find_all("li")
+                for date_element in date_elements:
+                    date_string = date_element.find("span").text.split(" ")[1]
+                    collection_date = datetime.strptime(
+                        date_string, "%d/%m/%Y"
+                    ).strftime(date_format)
+
+                    data["bins"].append(
+                        {
+                            "type": re.sub(r"[^a-zA-Z0-9,\s]", "", bin_type).strip(),
+                            "collectionDate": collection_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/ReadingBoroughCouncil.py

@@ -0,0 +1,30 @@
+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:
+        json_result = json.loads(page.text)
+
+        data = {"bins": []}
+
+        for collection in json_result["collections"]:
+            bin_type = collection["service"]
+            bin_collection = collection["date"]  # Date format is 14/12/2023 00:00:00
+
+            dict_data = {
+                "type": bin_type.replace(" Collection Service", " Bin"),
+                "collectionDate": datetime.strptime(
+                    bin_collection, "%d/%m/%Y %H:%M:%S"
+                ).strftime(date_format),
+            }
+
+            data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/ReigateAndBansteadBoroughCouncil.py

@@ -0,0 +1,81 @@
+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 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:
+            user_uprn = kwargs.get("uprn")
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+            check_uprn(user_uprn)
+            # Pad UPRN with 0's at the start for any that aren't 12 chars
+            user_uprn = user_uprn.zfill(12)
+
+            # Create Selenium webdriver
+            driver = create_webdriver(web_driver, headless)
+            driver.get(
+                f"https://my.reigate-banstead.gov.uk/en/service/Bins_and_recycling___collections_calendar?uprn={user_uprn}"
+            )
+
+            # Wait for iframe to load and switch to it
+            WebDriverWait(driver, 30).until(
+                EC.frame_to_be_available_and_switch_to_it((By.ID, "fillform-frame-1"))
+            )
+
+            # Wait for form
+            WebDriverWait(driver, 30).until(
+                EC.presence_of_element_located(
+                    (By.CSS_SELECTOR, 'span[data-name="html2"] > div')
+                )
+            )
+
+            # Make a BS4 object
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+            soup.prettify()
+
+            data = {"bins": []}
+            section = soup.find("span", {"data-name": "html2"})
+            dates = section.find_all("div")
+            for d in dates:
+                date = d.find("h3")
+                collections = d.find_all("li")
+                if date and collections:
+                    collection_date = datetime.strptime(
+                        date.get_text(strip=True), "%A %d %B %Y"
+                    ).strftime(date_format)
+                    for c in collections:
+                        collection_type = c.get_text(strip=True)
+                        if c.get_text(strip=True):
+                            dict_data = {
+                                "type": collection_type,
+                                "collectionDate": collection_date,
+                            }
+                            data["bins"].append(dict_data)
+
+            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