uk_bin_collection 0.119.0__py3-none-any.whl → 0.123.1__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/CumberlandAllerdaleCouncil.py

@@ -0,0 +1,93 @@
+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:
+
+        user_postcode = kwargs.get("postcode")
+        user_paon = kwargs.get("paon")
+        check_postcode(user_postcode)
+        check_paon(user_paon)
+        bindata = {"bins": []}
+
+        URI = "https://abc-wrp.whitespacews.com/"
+
+        session = requests.Session()
+
+        # get link from first page as has some kind of unique hash
+        r = session.get(
+            URI,
+        )
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, features="html.parser")
+
+        alink = soup.find("a", text="View My Collections")
+
+        if alink is None:
+            raise Exception("Initial page did not load correctly")
+
+        # greplace 'seq' query string to skip next step
+        nextpageurl = alink["href"].replace("seq=1", "seq=2")
+
+        data = {
+            "address_name_number": user_paon,
+            "address_postcode": user_postcode,
+        }
+
+        # get list of addresses
+        r = session.post(nextpageurl, data)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+
+        # get first address (if you don't enter enough argument values this won't find the right address)
+        alink = soup.find("div", id="property_list").find("a")
+
+        if alink is None:
+            raise Exception("Address not found")
+
+        nextpageurl = URI + alink["href"]
+
+        # get collection page
+        r = session.get(
+            nextpageurl,
+        )
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, features="html.parser")
+
+        if soup.find("span", id="waste-hint"):
+            raise Exception("No scheduled services at this address")
+
+        u1s = soup.find("section", id="scheduled-collections").find_all("u1")
+
+        for u1 in u1s:
+            lis = u1.find_all("li", recursive=False)
+
+            date = lis[1].text.replace("\n", "")
+            bin_type = lis[2].text.replace("\n", "")
+
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": datetime.strptime(
+                    date,
+                    "%d/%m/%Y",
+                ).strftime(date_format),
+            }
+            bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/EastAyrshireCouncil.py

@@ -30,14 +30,17 @@ class CouncilClass(AbstractGetBinDataClass):
         # Find each <time> element in the schedule
         for entry in soup.find_all("time"):
 
-            dict_data = {
-                "type": entry.find(class_="ScheduleItem").text.strip(),
-                "collectionDate": datetime.strptime(
-                    entry["datetime"],
-                    "%Y-%m-%d",
-                ).strftime("%d/%m/%Y"),
-            }
-            bindata["bins"].append(dict_data)
+            ScheduleItems = entry.find_all(class_="ScheduleItem")
+
+            for ScheduleItem in ScheduleItems:
+                dict_data = {
+                    "type": ScheduleItem.text.strip(),
+                    "collectionDate": datetime.strptime(
+                        entry["datetime"],
+                        "%Y-%m-%d",
+                    ).strftime("%d/%m/%Y"),
+                }
+                bindata["bins"].append(dict_data)
 
         bindata["bins"].sort(
             key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")

uk_bin_collection/uk_bin_collection/councils/EnvironmentFirst.py

@@ -1,4 +1,5 @@
 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
 
@@ -45,4 +46,17 @@ class CouncilClass(AbstractGetBinDataClass):
         }
         data["bins"].append(dict_data)
 
+        if len(page_text) > 5:
+            garden_day = datetime.strptime(
+                remove_ordinal_indicator_from_date_string(
+                    page_text[6].find_next("strong").text
+                ),
+                "%d %B %Y",
+            ).strftime(date_format)
+            dict_data = {
+                "type": "Garden",
+                "collectionDate": garden_day,
+            }
+            data["bins"].append(dict_data)
+
         return data

uk_bin_collection/uk_bin_collection/councils/FolkstoneandHytheDistrictCouncil.py

@@ -0,0 +1,81 @@
+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:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = f"https://service.folkestone-hythe.gov.uk/webapp/myarea/index.php?uprn={user_uprn}"
+
+        # Make the GET request
+        response = requests.get(URI)
+
+        soup = BeautifulSoup(response.content, "html.parser")
+
+        soup = soup.find("div", {"id": "bincollections"})
+
+        # Find the Recycling and Non-Recyclables sections
+        bin_schedule = {}
+
+        # Extract the recycling schedule
+        recycling_section = soup.find("span", text=lambda x: x and "Recycling" in x)
+        if recycling_section:
+            bin_types = recycling_section.text.replace("Recycling: ", "").split(" / ")
+            recycling_dates = recycling_section.find_next("ul").find_all("li")
+            bin_schedule["Recycling"] = [date.text.strip() for date in recycling_dates]
+            for date in recycling_dates:
+                for bin_type in bin_types:
+                    dict_data = {
+                        "type": bin_type.strip(),
+                        "collectionDate": datetime.strptime(
+                            remove_ordinal_indicator_from_date_string(
+                                date.text.strip()
+                            ),
+                            "%A %d %B %Y",
+                        ).strftime("%d/%m/%Y"),
+                    }
+                    bindata["bins"].append(dict_data)
+
+        # Extract the non-recyclables schedule
+        non_recyclables_section = soup.find(
+            "span", text=lambda x: x and "Non-Recyclables" in x
+        )
+        if non_recyclables_section:
+            bin_types = non_recyclables_section.text.replace(
+                "Non-Recyclables: ", ""
+            ).split(" / ")
+            non_recyclables_dates = non_recyclables_section.find_next("ul").find_all(
+                "li"
+            )
+            for date in non_recyclables_dates:
+                for bin_type in bin_types:
+                    dict_data = {
+                        "type": bin_type.strip(),
+                        "collectionDate": datetime.strptime(
+                            remove_ordinal_indicator_from_date_string(
+                                date.text.strip()
+                            ),
+                            "%A %d %B %Y",
+                        ).strftime("%d/%m/%Y"),
+                    }
+                    bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/GlasgowCityCouncil.py

@@ -27,6 +27,23 @@ class CouncilClass(AbstractGetBinDataClass):
             "../Images/Bins/ashBin.gif": "Ash bin",
         }
 
+        fieldset = soup.find("fieldset")
+        ps = fieldset.find_all("p")
+        for p in ps:
+            collection = p.text.strip().replace("Your next ", "").split(".")[0]
+            bin_type = collection.split(" day is")[0]
+            collection_date = datetime.strptime(
+                remove_ordinal_indicator_from_date_string(collection).split("day is ")[
+                    1
+                ],
+                "%A %d %B %Y",
+            )
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": collection_date.strftime(date_format),
+            }
+            data["bins"].append(dict_data)
+
         # Find the page body with all the calendars
         body = soup.find("div", {"id": "Application_ctl00"})
         calendars = body.find_all_next("table", {"title": "Calendar"})

uk_bin_collection/uk_bin_collection/councils/HackneyCouncil.py

@@ -0,0 +1,85 @@
+import time
+
+import requests
+
+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_paon = kwargs.get("paon")
+        user_postcode = kwargs.get("postcode")
+        check_postcode(user_postcode)
+        check_paon(user_paon)
+        bindata = {"bins": []}
+
+        URI = "https://waste-api-hackney-live.ieg4.net/f806d91c-e133-43a6-ba9a-c0ae4f4cccf6/property/opensearch"
+
+        data = {
+            "Postcode": user_postcode,
+        }
+        headers = {"Content-Type": "application/json"}
+
+        # Make the GET request
+        response = requests.post(URI, json=data, headers=headers)
+
+        addresses = response.json()
+
+        for address in addresses["addressSummaries"]:
+            summary = address["summary"]
+            if user_paon in summary:
+                systemId = address["systemId"]
+        if systemId:
+            URI = f"https://waste-api-hackney-live.ieg4.net/f806d91c-e133-43a6-ba9a-c0ae4f4cccf6/alloywastepages/getproperty/{systemId}"
+
+            response = requests.get(URI)
+
+            address = response.json()
+
+            binIDs = address["providerSpecificFields"][
+                "attributes_wasteContainersAssignableWasteContainers"
+            ]
+            for binID in binIDs.split(","):
+                URI = f"https://waste-api-hackney-live.ieg4.net/f806d91c-e133-43a6-ba9a-c0ae4f4cccf6/alloywastepages/getbin/{binID}"
+                response = requests.get(URI)
+                getBin = response.json()
+
+                bin_type = getBin["subTitle"]
+
+                URI = f"https://waste-api-hackney-live.ieg4.net/f806d91c-e133-43a6-ba9a-c0ae4f4cccf6/alloywastepages/getcollection/{binID}"
+                response = requests.get(URI)
+                getcollection = response.json()
+
+                collectionID = getcollection["scheduleCodeWorkflowID"]
+
+                URI = f"https://waste-api-hackney-live.ieg4.net/f806d91c-e133-43a6-ba9a-c0ae4f4cccf6/alloywastepages/getworkflow/{collectionID}"
+                response = requests.get(URI)
+                collection_dates = response.json()
+
+                dates = collection_dates["trigger"]["dates"]
+
+                for date in dates:
+                    parsed_datetime = datetime.strptime(
+                        date, "%Y-%m-%dT%H:%M:%SZ"
+                    ).strftime(date_format)
+
+                    dict_data = {
+                        "type": bin_type.strip(),
+                        "collectionDate": parsed_datetime,
+                    }
+                    bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/HartlepoolBoroughCouncil.py

@@ -0,0 +1,83 @@
+import time
+
+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:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        SESSION_URL = "https://online.hartlepool.gov.uk/authapi/isauthenticated?uri=https%253A%252F%252Fonline.hartlepool.gov.uk%252Fservice%252FRefuse_and_recycling___check_bin_day&hostname=online.hartlepool.gov.uk&withCredentials=true"
+
+        API_URL = "https://online.hartlepool.gov.uk/apibroker/runLookup"
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://online.hartlepool.gov.uk/fillform/?iframe_id=fillform-frame-1&db_id=",
+        }
+        s = requests.session()
+        r = s.get(SESSION_URL)
+        r.raise_for_status()
+        session_data = r.json()
+        sid = session_data["auth-session"]
+        params = {
+            "id": "5ec67e019ffdd",
+            "repeat_against": "",
+            "noRetry": "true",
+            "getOnlyTokens": "undefined",
+            "log_id": "",
+            "app_name": "AF-Renderer::Self",
+            # unix_timestamp
+            "_": str(int(time.time() * 1000)),
+            "sid": sid,
+        }
+
+        data = {
+            "formValues": {
+                "Section 1": {
+                    "collectionLocationUPRN": {
+                        "value": user_uprn,
+                    },
+                },
+            },
+        }
+
+        r = s.post(API_URL, json=data, headers=headers, params=params)
+        r.raise_for_status()
+
+        data = r.json()
+        rows_data = data["integration"]["transformed"]["rows_data"]["0"]
+        if not isinstance(rows_data, dict):
+            raise ValueError("Invalid data returned from API")
+
+        soup = BeautifulSoup(rows_data["HTMLCollectionDatesText"], "html.parser")
+
+        # Find all div elements containing the bin schedule
+        for div in soup.find_all("div"):
+            # Extract bin type and date from the span tag
+            text = div.find("span").text.strip()
+            bin_type, date = text.split(" ", 1)
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": date,
+            }
+            bindata["bins"].append(dict_data)
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/HighPeakCouncil.py

@@ -83,11 +83,16 @@ class CouncilClass(AbstractGetBinDataClass):
             )
 
             # 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.element_to_be_clickable(
+                    (
+                        By.XPATH,
+                        "//select[@id='FINDBINDAYSHIGHPEAK_ADDRESSSELECT_ADDRESS']//option[contains(., '"
+                        + user_paon
+                        + "')]",
+                    )
+                )
+            ).click()
 
             WebDriverWait(driver, 10).until(
                 EC.presence_of_element_located(

uk_bin_collection/uk_bin_collection/councils/HinckleyandBosworthBoroughCouncil.py

@@ -0,0 +1,71 @@
+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:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = f"https://www.hinckley-bosworth.gov.uk/set-location?id={user_uprn}&redirect=refuse&rememberloc="
+
+        # Make the GET request
+        response = requests.get(URI)
+
+        # Parse the HTML
+        soup = BeautifulSoup(response.content, "html.parser")
+
+        # Find all the bin collection date containers
+        bin_schedule = []
+        collection_divs = soup.find_all(
+            "div", class_=["first_date_bins", "last_date_bins"]
+        )
+
+        for div in collection_divs:
+            # Extract the date
+            date = div.find("h3", class_="collectiondate").text.strip().replace(":", "")
+
+            # Extract bin types
+            bins = [img["alt"] for img in div.find_all("img", class_="collection")]
+
+            # Append to the schedule
+            bin_schedule.append({"date": date, "bins": bins})
+
+        current_year = datetime.now().year
+        current_month = datetime.now().month
+
+        # Print the schedule
+        for entry in bin_schedule:
+            bin_types = entry["bins"]
+            date = datetime.strptime(entry["date"], "%d %B")
+
+            if (current_month > 9) and (date.month < 4):
+                date = date.replace(year=(current_year + 1))
+            else:
+                date = date.replace(year=current_year)
+
+            for bin_type in bin_types:
+
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": date.strftime("%d/%m/%Y"),
+                }
+                bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/KingsLynnandWestNorfolkBC.py

@@ -0,0 +1,59 @@
+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:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        user_uprn = user_uprn.zfill(12)
+        bindata = {"bins": []}
+
+        URI = "https://www.west-norfolk.gov.uk/info/20174/bins_and_recycling_collection_dates"
+
+        headers = {"Cookie": f"bcklwn_uprn={user_uprn}"}
+
+        # Make the GET request
+        response = requests.get(URI, headers=headers)
+
+        soup = BeautifulSoup(response.content, features="html.parser")
+        soup.prettify()
+
+        # Find all bin_date_container divs
+        bin_date_containers = soup.find_all("div", class_="bin_date_container")
+
+        # Loop through each bin_date_container
+        for container in bin_date_containers:
+            # Extract the collection date
+            date = (
+                container.find("h3", class_="collectiondate").text.strip().rstrip(":")
+            )
+
+            # Extract the bin type from the alt attribute of the img tag
+            bin_type = container.find("img")["alt"]
+
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": datetime.strptime(
+                    date,
+                    "%A %d %B %Y",
+                ).strftime("%d/%m/%Y"),
+            }
+            bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/LondonBoroughHavering.py

@@ -0,0 +1,75 @@
+import time
+
+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:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = "https://lbhapiprod.azure-api.net"
+        endpoint = f"{URI}/whitespace/GetCollectionByUprnAndDate"
+        subscription_key = "2ea6a75f9ea34bb58d299a0c9f84e72e"
+
+        # Get today's date in 'YYYY-MM-DD' format
+        collection_date = datetime.now().strftime("%Y-%m-%d")
+
+        # Define the request headers
+        headers = {
+            "Content-Type": "application/json",
+            "Ocp-Apim-Subscription-Key": subscription_key,
+        }
+
+        # Define the request body
+        data = {
+            "getCollectionByUprnAndDate": {
+                "getCollectionByUprnAndDateInput": {
+                    "uprn": user_uprn,
+                    "nextCollectionFromDate": collection_date,
+                }
+            }
+        }
+        # Make the POST request
+        response = requests.post(endpoint, headers=headers, data=json.dumps(data))
+        response.raise_for_status()  # Raise an exception for HTTP errors
+
+        # Parse the JSON response
+        response_data = response.json()
+
+        collections = (
+            response_data.get("getCollectionByUprnAndDateResponse", {})
+            .get("getCollectionByUprnAndDateResult", {})
+            .get("Collections", [])
+        )
+
+        for collection in collections:
+            bin_type = collection["service"]
+            collection_date = collection["date"]
+
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": datetime.strptime(
+                    collection_date,
+                    "%d/%m/%Y %H:%M:%S",
+                ).strftime(date_format),
+            }
+            bindata["bins"].append(dict_data)
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
+        )
+
+        return bindata