uk_bin_collection 0.74.0__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/StockportBoroughCouncil.py

@@ -0,0 +1,39 @@
+# This script pulls (in one hit) the
+# data from Warick District Council Bins Data
+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:
+        # Make a BS4 object
+        soup = BeautifulSoup(page.text, features="html.parser")
+        soup.prettify()
+
+        data = {"bins": []}
+
+        for bins in soup.select('div[class*="service-item"]'):
+            bin_type = bins.div.h3.text.strip()
+            binCollection = datetime.strptime(
+                bins.select("div > p")[1].get_text(strip=True), "%A, %d %B %Y"
+            )
+            # binImage = "https://myaccount.stockport.gov.uk" + bins.img['src']
+
+            # batteries don't have a service date or other
+            # info associated with them.
+            if binCollection:
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": binCollection.strftime(date_format),
+                }
+                data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/StokeOnTrentCityCouncil.py

@@ -0,0 +1,79 @@
+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:
+        # Make a BS4 object
+        soup = BeautifulSoup(page.text, features="lxml-xml")
+        soup.prettify()
+
+        data = {"bins": []}
+        collections = []
+
+        # Match bin types from API to their actual type
+        bin_types = {
+            "RESIDUAL BIN": "Grey bin",
+            "RES 180": "Grey bin",
+            "RES 240 STD": "Grey bin",
+            "RES 360 STD+": "Grey bin",
+            "RES 360 STD": "Grey bin",
+            "RES 660": "Grey bin",
+            "RES 770": "Grey bin",
+            "RES BAG": "Grey bin",
+            "RES 140 SML": "Grey bin",
+            "REC 180 SML": "Blue bin",
+            "REC 240 STD": "Blue bin",
+            "REC 360": "Blue bin",
+            "REC 770": "Blue bin",
+            "MIXED REC 55 BOX": "Blue box",
+            "PAPER 44 BOX": "Blue box",
+            "PAPER BAG": "Paper bag",
+            "ORG 180": "Brown bin",
+            "ORG 240 STD": "Brown bin",
+            "PAID ORGANIC": "Brown bin",
+            "RES 1100": "Grey trade container",
+            "REC GL 770": "Blue trade container",
+        }
+        # If the API errors, throw the exception
+        if soup.find("Error") is not None:
+            raise ConnectionAbortedError(soup.find("Error").text.strip())
+
+        # Parse the XML and add to a list of collections
+        for item in soup.find_all("BinRound"):
+            try:
+                bin_type = bin_types.get(
+                    item.find_next("Bin").text.replace("EMPTY BINS", "").strip()
+                )
+                bin_date = datetime.strptime(
+                    item.find_next("DateTime").text, "%d/%m/%Y %H:%M:%S"
+                )
+                if bin_date >= datetime.now():
+                    collections.append((bin_type, bin_date))
+            except:
+                raise SystemError(
+                    "Error has been encountered parsing API. Please try again later and if the issue "
+                    "persists, open a GitHub ticket!"
+                )
+
+        # Sort the collections list 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/StratfordUponAvonCouncil.py

@@ -0,0 +1,94 @@
+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:
+        driver = None
+        try:
+            # Get postcode and UPRN from kwargs
+            # user_postcode = kwargs.get("postcode")
+            user_uprn = kwargs.get("uprn")
+            # check_postcode(user_postcode)
+            check_uprn(user_uprn)
+            url = "https://www.stratford.gov.uk/waste-recycling/when-we-collect.cfm/part/calendar"
+            payload = {
+                "frmAddress1": "",
+                "frmAddress2": "",
+                "frmAddress3": "",
+                "frmAddress4": "",
+                "frmPostcode": "",
+                "frmUPRN": user_uprn,
+            }
+            headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+            requests.packages.urllib3.disable_warnings()
+            response = requests.request("POST", url, data=payload, headers=headers)
+
+            # Make a BS4 object
+            soup = BeautifulSoup(response.content, features="html.parser")
+            soup.prettify()
+
+            # Find the table
+            table = soup.find("table", class_="table")
+
+            data = {"bins": []}
+
+            if table:
+                # Extract the column headers (bin names)
+                column_headers = [
+                    header.text.strip()
+                    for header in table.select("thead th.text-center strong")
+                ]
+
+                # Extract the rows containing collection information
+                collection_rows = table.select("tbody tr")
+
+                # Create a dictionary to store the next date for each bin
+                next_collection_dates = {bin: None for bin in column_headers}
+
+                # Iterate through the rows
+                for row in collection_rows:
+                    # Get the date from the first cell
+                    date_str = row.find("td").text.strip()
+                    date_obj = datetime.strptime(date_str, "%A, %d/%m/%Y")
+
+                    # Get the collection information for each bin (td elements with title attribute)
+                    collection_info = [
+                        cell["title"] if cell["title"] else "Not Collected"
+                        for cell in row.select("td.text-center")
+                    ]
+
+                    # Iterate through each bin type and its collection date
+                    for bin, status in zip(column_headers, collection_info):
+                        # If the bin hasn't had a collection date yet or the new date is earlier, update it
+                        if status != "Not Collected" and (
+                            not next_collection_dates[bin]
+                            or date_obj < next_collection_dates[bin]
+                        ):
+                            next_collection_dates[bin] = date_obj
+
+                data["bins"] = [
+                    {"type": bin, "collectionDate": next_date.strftime(date_format)}
+                    for bin, next_date in next_collection_dates.items()
+                ]
+            else:
+                print("Table not found in the HTML content.")
+        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/SunderlandCityCouncil.py

@@ -0,0 +1,100 @@
+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 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 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": []}
+            collections = []
+
+            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)
+
+            driver = create_webdriver(web_driver, headless)
+            # driver = webdriver.Chrome(service=ChromeService(ChromeDriverManager().install()))
+            driver.get(
+                "https://webapps.sunderland.gov.uk/WEBAPPS/WSS/Sunderland_Portal/Forms/bindaychecker.aspx"
+            )
+
+            inputElement_postcode = WebDriverWait(driver, 30).until(
+                EC.presence_of_element_located(
+                    (By.ID, "ContentPlaceHolder1_tbPostCode_controltext")
+                )
+            )
+            inputElement_postcode.send_keys(user_postcode)
+
+            inputElement_submit_button = WebDriverWait(driver, 30).until(
+                EC.element_to_be_clickable((By.ID, "ContentPlaceHolder1_btnLLPG"))
+            )
+            inputElement_submit_button.click()
+
+            addressList = WebDriverWait(driver, 30).until(
+                EC.presence_of_element_located(
+                    (By.ID, "ContentPlaceHolder1_ddlAddresses")
+                )
+            )
+            selected_addressList = Select(addressList)
+            for idx, addr_option in enumerate(selected_addressList.options):
+                option_name = addr_option.accessible_name[0 : len(user_paon)]
+                if option_name == user_paon:
+                    break
+            selected_addressList.select_by_index(idx)
+
+            # Make a BS4 object
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+            soup.prettify()
+
+            household_bin_date = datetime.strptime(
+                soup.find("span", {"id": "ContentPlaceHolder1_LabelHouse"}).get_text(
+                    strip=True
+                ),
+                "%A %d %B %Y",
+            )
+            collections.append(("Household bin", household_bin_date))
+
+            recycling_bin_date = datetime.strptime(
+                soup.find("span", {"id": "ContentPlaceHolder1_LabelRecycle"}).get_text(
+                    strip=True
+                ),
+                "%A %d %B %Y",
+            )
+            collections.append(("Recycling bin", recycling_bin_date))
+
+            ordered_data = sorted(collections, key=lambda x: x[1])
+            for item in ordered_data:
+                dict_data = {
+                    "type": item[0].capitalize(),
+                    "collectionDate": item[1].strftime(date_format),
+                }
+                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/SwaleBoroughCouncil.py

@@ -0,0 +1,52 @@
+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:
+        # Get postcode and UPRN from kwargs
+        user_postcode = kwargs.get("postcode")
+        user_uprn = kwargs.get("uprn")
+        check_postcode(user_postcode)
+        check_uprn(user_uprn)
+
+        # Build URL to parse
+        council_url = f"https://swale.gov.uk/bins-littering-and-the-environment/bins/collection-days?postcode={user_postcode.replace(' ', '+')}&addresses={user_uprn}&address-submit="
+
+        # Parse URL and read if connection successful
+        requests.packages.urllib3.disable_warnings()
+        response = requests.get(council_url, verify=False)
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, features="html.parser")
+            soup.prettify()
+        else:
+            raise ConnectionAbortedError("Could not parse council website.")
+
+        data = {"bins": []}
+
+        # Get the collection bullet points on the page and parse them
+        form_area = soup.find("form", {"class": "integration bin-lookup"})
+        collections = [
+            item.text.strip().split(",") for item in form_area.find_all("li")
+        ]
+        for c in collections:
+            bin_type = c[0].strip()
+            # temp_date = c[2].strip() + " " + str(datetime.now().year)
+            bin_date = datetime.strptime(
+                c[2].strip() + " " + str(datetime.now().year), "%d %B %Y"
+            ).strftime(date_format)
+            dict_data = {"type": bin_type, "collectionDate": bin_date}
+            data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/TamesideMBCouncil.py

@@ -0,0 +1,62 @@
+import json
+from datetime import datetime, timedelta
+
+import requests
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+class CouncilClass(AbstractGetBinDataClass):
+    def parse_data(self, page: str, **kwargs) -> dict:
+        api_url = "http://lite.tameside.gov.uk/BinCollections/CollectionService.svc/GetBinCollection"
+        uprn = kwargs.get("uprn")
+        check_uprn(uprn)
+
+        params = {
+            "version": "3.1.4",
+            "uprn": uprn,
+            "token": "",
+            "notification": "1",
+            "operatingsystemid": "2",
+            "testmode": "true",
+        }
+
+        headers = {"content-type": "text/plain"}
+
+        requests.packages.urllib3.disable_warnings()
+        response = requests.post(api_url, json=params, headers=headers)
+
+        json_response = json.loads(response.content)["GetBinCollectionResult"]["Data"]
+
+        today = datetime.today()
+        eight_weeks = datetime.today() + timedelta(days=8 * 7)
+        data = {"bins": []}
+        collection_tuple = []
+
+        bin_friendly_names = {
+            "2": "Blue Bin",
+            "6": "Green Bin",
+            "5": "Black Bin",
+            "3": "Brown Bin",
+        }
+
+        for item in json_response:
+            collection_date = datetime.strptime(
+                item.get("CollectionDate"), "%d/%m/%Y %H:%M:%S"
+            )
+            if today.date() <= collection_date.date() <= eight_weeks.date():
+                bin_type = bin_friendly_names.get(item.get("BinType"))
+                collection_tuple.append(
+                    (bin_type, collection_date.strftime(date_format))
+                )
+
+        ordered_data = sorted(collection_tuple, key=lambda x: x[1])
+
+        for item in ordered_data:
+            dict_data = {
+                "type": item[0],
+                "collectionDate": item[1],
+            }
+            data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/TandridgeDistrictCouncil.py

@@ -0,0 +1,60 @@
+import requests
+import json
+import urllib.parse
+from dateutil.relativedelta import relativedelta
+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": "application/json, text/javascript, */*; q=0.01",
+            "Accept-Language": "en-GB,en;q=0.9",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            # Already added when you pass json=
+            # 'Content-Type': 'application/json',
+            # 'Cookie': 'ASP.NET_SessionId=n2kxv5ssap4gobb11va1oxge',
+            "Origin": "https://tdcws01.tandridge.gov.uk",
+            "Pragma": "no-cache",
+            "Referer": "https://tdcws01.tandridge.gov.uk/TDCWebAppsPublic/tfaBranded/408?utm_source=pressrelease&utm_medium=smposts&utm_campaign=check_my_bin_day",
+            "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",
+        }
+
+        params = {
+            "UPRN": f"{user_uprn}",
+        }
+
+        json_data = requests.post(
+            "https://tdcws01.tandridge.gov.uk/TDCWebAppsPublic/TDCMiddleware/RESTAPI/WhiteSpaceAPI/GetCompleteRecordByUPRN",
+            headers=headers,
+            json=params,
+        ).json()["lstNextCollections"]
+
+        for item in json_data:
+            dict_data = {
+                "type": item.get("Service").replace("Collection Service", "").strip(),
+                "collectionDate": datetime.strptime(
+                    item.get("Date"), "%d/%m/%Y %H:%M:%S"
+                ).strftime(date_format),
+            }
+            data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/TelfordAndWrekinCouncil.py

@@ -0,0 +1,50 @@
+import requests
+import json
+
+from dateutil.relativedelta import relativedelta
+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": []}
+        collections = []
+        api_url = f"https://dac.telford.gov.uk/BinDayFinder/Find/PropertySearch?uprn={user_uprn}"
+
+        response = requests.get(api_url)
+        if response.status_code != 200:
+            raise ConnectionError("Could not get latest data!")
+
+        json_data = json.loads(response.text.replace("\\", "")[1:-1])["bincollections"]
+        for item in json_data:
+            collection_date = datetime.strptime(
+                remove_ordinal_indicator_from_date_string(item.get("nextDate")),
+                "%A %d %B",
+            )
+            next_collection = collection_date.replace(year=datetime.now().year)
+            if datetime.now().month == 12 and next_collection.month == 1:
+                next_collection = next_collection + relativedelta(years=1)
+
+            collections.append((item.get("name"), next_collection))
+
+        ordered_data = sorted(collections, 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