uk_bin_collection 0.102.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/EnfieldCouncil.py

@@ -56,9 +56,7 @@ class CouncilClass(AbstractGetBinDataClass):
             postcode_input.send_keys(user_postcode)
 
             find_address_button = WebDriverWait(driver, 10).until(
-                EC.presence_of_element_located(
-                    (By.ID, 'submitButton0')
-                )
+                EC.presence_of_element_located((By.ID, "submitButton0"))
             )
             find_address_button.click()
 
@@ -80,7 +78,7 @@ class CouncilClass(AbstractGetBinDataClass):
             template_parts = first_option.split(", ")
             template_parts[0] = user_paon  # Replace the first part with user_paon
 
-            addr_label =  ", ".join(template_parts)
+            addr_label = ", ".join(template_parts)
             for addr_option in select.options:
                 option_name = addr_option.accessible_name[0 : len(addr_label)]
                 if option_name == addr_label:
@@ -100,32 +98,27 @@ class CouncilClass(AbstractGetBinDataClass):
             # Find the div with the specified id
             target_div = soup.find("div", {"id": target_div_id})
 
-
             # Check if the div is found
             if target_div:
                 bin_data = {"bins": []}
 
-                for bin_div in target_div.find_all(
-                    "div"
-                ):
+                for bin_div in target_div.find_all("div"):
                     # Extract the collection date from the message
                     try:
                         bin_collection_message = bin_div.find("p").text.strip()
                         date_pattern = r"\b\d{2}/\d{2}/\d{4}\b"
 
                         collection_date_string = (
-                        re.search(date_pattern, bin_div.text)
-                        .group(0)
-                        .strip()
-                        .replace(",", "")
-                    )
+                            re.search(date_pattern, bin_div.text)
+                            .group(0)
+                            .strip()
+                            .replace(",", "")
+                        )
                     except AttributeError:
                         continue
 
                     current_date = datetime.now()
-                    parsed_date = datetime.strptime(
-                        collection_date_string, "%d/%m/%Y"
-                    )
+                    parsed_date = datetime.strptime(collection_date_string, "%d/%m/%Y")
                     # Check if the parsed date is in the past and not today
                     if parsed_date.date() < current_date.date():
                         # If so, set the year to the next year
@@ -137,9 +130,14 @@ class CouncilClass(AbstractGetBinDataClass):
                     contains_date(formatted_date)
 
                     # Extract the bin type from the message
-                    bin_type_match = re.search(r"Your next (.*?) collection", bin_collection_message)
+                    bin_type_match = re.search(
+                        r"Your next (.*?) collection", bin_collection_message
+                    )
                     if bin_type_match:
-                        bin_info = {"type": bin_type_match.group(1), "collectionDate": formatted_date}
+                        bin_info = {
+                            "type": bin_type_match.group(1),
+                            "collectionDate": formatted_date,
+                        }
                         bin_data["bins"].append(bin_info)
             else:
                 raise ValueError("Collection data not found.")

uk_bin_collection/uk_bin_collection/councils/GedlingBoroughCouncil.py

@@ -16,7 +16,7 @@ class CouncilClass(AbstractGetBinDataClass):
     def parse_data(self, page: str, **kwargs) -> dict:
         data = {"bins": []}
         collections = []
-        selected_collections = kwargs.get("paon").split(',')
+        selected_collections = kwargs.get("paon").split(",")
         calendar_urls = []
         run_date = datetime.now().date()
 
@@ -25,9 +25,13 @@ class CouncilClass(AbstractGetBinDataClass):
         for item in selected_collections:
             item = item.strip().lower().replace(" ", "_")
             if has_numbers(item):
-                calendar_urls.append(f"https://www.gbcbincalendars.co.uk/json/gedling_borough_council_{item}_bin_schedule.json")
+                calendar_urls.append(
+                    f"https://www.gbcbincalendars.co.uk/json/gedling_borough_council_{item}_bin_schedule.json"
+                )
             else:
-                calendar_urls.append(f"https://www.gbcbincalendars.co.uk/json/gedling_borough_council_{item}_garden_bin_schedule.json")
+                calendar_urls.append(
+                    f"https://www.gbcbincalendars.co.uk/json/gedling_borough_council_{item}_garden_bin_schedule.json"
+                )
 
         # Parse each URL and load future data
         for url in calendar_urls:
@@ -36,7 +40,9 @@ class CouncilClass(AbstractGetBinDataClass):
                 raise ConnectionError(f"Could not get response from: {url}")
             json_data = response.json()["collectionDates"]
             for col in json_data:
-                bin_date = datetime.strptime(col.get("collectionDate"), "%Y-%m-%d").date()
+                bin_date = datetime.strptime(
+                    col.get("collectionDate"), "%Y-%m-%d"
+                ).date()
                 if bin_date >= run_date:
                     collections.append((col.get("alternativeName"), bin_date))
 

uk_bin_collection/uk_bin_collection/councils/IslingtonCouncil.py

@@ -29,9 +29,11 @@ class CouncilClass(AbstractGetBinDataClass):
                 waste_type = row.find("th").text.strip()
                 next_collection = parse(row.find("td").text.strip()).date()
 
-                data['bins'].append({
-                    "type": waste_type,
-                    "collectionDate": next_collection.strftime(date_format),
-                })
+                data["bins"].append(
+                    {
+                        "type": waste_type,
+                        "collectionDate": next_collection.strftime(date_format),
+                    }
+                )
 
         return data

uk_bin_collection/uk_bin_collection/councils/LutonBoroughCouncil.py

@@ -0,0 +1,81 @@
+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://myforms.luton.gov.uk/authapi/isauthenticated?uri=https%253A%252F%252Fmyforms.luton.gov.uk%252Fservice%252FFind_my_bin_collection_date&hostname=myforms.luton.gov.uk&withCredentials=true"
+
+        API_URL = "https://myforms.luton.gov.uk/apibroker/runLookup"
+
+        data = {
+            "formValues": {
+                "Find my bin collection date": {
+                    "id": {
+                        "value": f"1-{user_uprn}",
+                    },
+                },
+            }
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://myforms.luton.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": "65cb710f8d525",
+            "repeat_against": "",
+            "noRetry": "true",
+            "getOnlyTokens": "undefined",
+            "log_id": "",
+            "app_name": "AF-Renderer::Self",
+            # unix_timestamp
+            "_": str(int(time.time() * 1000)),
+            "sid": sid,
+        }
+        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"][f"{user_uprn}"]
+
+        soup = BeautifulSoup(rows_data["html"], features="html.parser")
+        soup.prettify()
+        for collection in soup.find_all("tr"):
+            tds = collection.find_all("td")
+            bin_type = tds[1].text
+            collection_date = datetime.strptime(
+                tds[0].text,
+                "%A %d %b %Y",
+            )
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": collection_date.strftime(date_format),
+            }
+            bindata["bins"].append(dict_data)
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/MoleValleyDistrictCouncil.py

@@ -7,6 +7,7 @@ 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):
     def parse_data(self, page: str, **kwargs) -> dict:
 
@@ -14,7 +15,9 @@ class CouncilClass(AbstractGetBinDataClass):
         check_postcode(user_postcode)
 
         # Fetch the page content
-        root_url = "https://myproperty.molevalley.gov.uk/molevalley/api/live_addresses/{}?format=json".format(user_postcode)
+        root_url = "https://myproperty.molevalley.gov.uk/molevalley/api/live_addresses/{}?format=json".format(
+            user_postcode
+        )
         response = requests.get(root_url, verify=False)
 
         if not response.ok:
@@ -63,23 +66,27 @@ class CouncilClass(AbstractGetBinDataClass):
         if bins_panel:
             panel = bins_panel.find_parent("div", class_="panel")
             print("Found 'Bins and Recycling' panel.")
-            
+
             # Extract bin collection info from the un-commented HTML
             for strong_tag in panel.find_all("strong"):
                 bin_type = strong_tag.text.strip()
                 collection_string = strong_tag.find_next("p").text.strip()
-                
+
                 # Debugging output
                 print(f"Processing bin type: {bin_type}")
                 print(f"Collection string: {collection_string}")
-                
+
                 match = regex_date.search(collection_string)
                 if match:
-                    collection_date = datetime.strptime(match.group(1), "%d/%m/%Y").date()
-                    data["bins"].append({
-                        "type": bin_type,
-                        "collectionDate": collection_date.strftime("%d/%m/%Y"),
-                    })
+                    collection_date = datetime.strptime(
+                        match.group(1), "%d/%m/%Y"
+                    ).date()
+                    data["bins"].append(
+                        {
+                            "type": bin_type,
+                            "collectionDate": collection_date.strftime("%d/%m/%Y"),
+                        }
+                    )
                     all_collection_dates.append(collection_date)
                 else:
                     # Add a debug line to show which collections are missing dates
@@ -88,7 +95,7 @@ class CouncilClass(AbstractGetBinDataClass):
             # Search for additional collections like electrical and textiles
             for p in panel.find_all("p"):
                 additional_match = regex_additional_collection.match(p.text.strip())
-                
+
                 # Debugging output for additional collections
                 if additional_match:
                     bin_type = additional_match.group(1)
@@ -96,23 +103,33 @@ class CouncilClass(AbstractGetBinDataClass):
                     if "each collection day" in additional_match.group(2):
                         if all_collection_dates:
                             collection_date = min(all_collection_dates)
-                            data["bins"].append({
-                                "type": bin_type,
-                                "collectionDate": collection_date.strftime("%d/%m/%Y"),
-                            })
+                            data["bins"].append(
+                                {
+                                    "type": bin_type,
+                                    "collectionDate": collection_date.strftime(
+                                        "%d/%m/%Y"
+                                    ),
+                                }
+                            )
                         else:
-                            print("No collection dates available for additional collection.")
+                            print(
+                                "No collection dates available for additional collection."
+                            )
                             raise ValueError("No valid bin collection dates found.")
                 else:
-                    print(f"No additional collection found in paragraph: {p.text.strip()}")
+                    print(
+                        f"No additional collection found in paragraph: {p.text.strip()}"
+                    )
         else:
-            raise ValueError("Unable to find 'Bins and Recycling' panel in the HTML data.")
+            raise ValueError(
+                "Unable to find 'Bins and Recycling' panel in the HTML data."
+            )
 
         # Debugging to check collected data
         print(f"Collected bin data: {data}")
-        
+
         # Handle the case where no collection dates were found
         if not all_collection_dates:
             raise ValueError("No valid collection dates were found in the data.")
-        
-        return data
+
+        return data

uk_bin_collection/uk_bin_collection/councils/NorthTynesideCouncil.py

@@ -23,7 +23,7 @@ class CouncilClass(AbstractGetBinDataClass):
         # Get the first form
         response = s.get(
             "https://my.northtyneside.gov.uk/category/81/bin-collection-dates",
-            verify = False,
+            verify=False,
         )
 
         # Find the form ID and submit with a postcode
@@ -31,13 +31,13 @@ class CouncilClass(AbstractGetBinDataClass):
         form_build_id = soup.find("input", {"name": "form_build_id"})["value"]
         response = s.post(
             "https://my.northtyneside.gov.uk/category/81/bin-collection-dates",
-            data = {
+            data={
                 "postcode": user_postcode,
                 "op": "Find",
                 "form_build_id": form_build_id,
                 "form_id": "ntc_address_wizard",
             },
-            verify = False,
+            verify=False,
         )
 
         # Find the form ID and submit with the UPRN
@@ -45,18 +45,18 @@ class CouncilClass(AbstractGetBinDataClass):
         form_build_id = soup.find("input", {"name": "form_build_id"})["value"]
         response = s.post(
             "https://my.northtyneside.gov.uk/category/81/bin-collection-dates",
-            data = {
+            data={
                 "house_number": f"0000{user_uprn}",
                 "op": "Use",
                 "form_build_id": form_build_id,
                 "form_id": "ntc_address_wizard",
             },
-            verify = False,
+            verify=False,
         )
 
         # Parse form page and get the day of week and week offsets
         soup = BeautifulSoup(response.text, features="html.parser")
-        info_section  = soup.find("section", {"class": "block block-ntc-bins clearfix"})
+        info_section = soup.find("section", {"class": "block block-ntc-bins clearfix"})
 
         regular_day, garden_day, special_day = None, None, None
         # Get day of week and week label for refuse, garden and special collections.
@@ -82,7 +82,9 @@ class CouncilClass(AbstractGetBinDataClass):
         weeks_total = math.floor((datetime(2026, 4, 1) - datetime.now()).days / 7)
 
         # The garden calendar only shows until end of November 2024, work out how many weeks that is
-        garden_weeks_total = math.floor((datetime(2024, 12, 1) - datetime.now()).days / 7)
+        garden_weeks_total = math.floor(
+            (datetime(2024, 12, 1) - datetime.now()).days / 7
+        )
 
         regular_collections, garden_collections, special_collections = [], [], []
         # Convert day text to series of dates using previous calculation
@@ -134,10 +136,10 @@ class CouncilClass(AbstractGetBinDataClass):
 
         return {
             "bins": [
-                    {
+                {
                     "type": item[0],
                     "collectionDate": item[1].strftime(date_format),
                 }
                 for item in sorted(collections, key=lambda x: x[1])
             ]
-        }
+        }

uk_bin_collection/uk_bin_collection/councils/RochfordCouncil.py

@@ -36,8 +36,7 @@ class CouncilClass(AbstractGetBinDataClass):
                     collection_date = datetime.strptime(
                         remove_ordinal_indicator_from_date_string(
                             week_text[0].split(" - ")[0]
-                        )
-                        .strip(),
+                        ).strip(),
                         "%A %d %B",
                     )
                     next_collection = collection_date.replace(year=datetime.now().year)

uk_bin_collection/uk_bin_collection/councils/RotherhamCouncil.py

@@ -17,7 +17,9 @@ class CouncilClass(AbstractGetBinDataClass):
         check_uprn(user_uprn)
 
         response = requests.post(
-            "https://www.rotherham.gov.uk/bin-collections?address={}&submit=Submit".format(user_uprn)
+            "https://www.rotherham.gov.uk/bin-collections?address={}&submit=Submit".format(
+                user_uprn
+            )
         )
         # Make a BS4 object
         soup = BeautifulSoup(response.text, features="html.parser")
@@ -25,15 +27,15 @@ class CouncilClass(AbstractGetBinDataClass):
 
         data = {"bins": []}
 
-        table = soup.select('table')[0]
+        table = soup.select("table")[0]
 
         if table:
-            rows = table.select('tr')
+            rows = table.select("tr")
 
             for index, row in enumerate(rows):
-                bin_info_cell = row.select('td')
-                if bin_info_cell: 
-                    bin_type = bin_info_cell[0].get_text(separator=' ', strip=True)
+                bin_info_cell = row.select("td")
+                if bin_info_cell:
+                    bin_type = bin_info_cell[0].get_text(separator=" ", strip=True)
                     bin_collection = bin_info_cell[1]
 
                     if bin_collection:

uk_bin_collection/uk_bin_collection/councils/SwindonBoroughCouncil.py

@@ -0,0 +1,56 @@
+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 = f"https://www.swindon.gov.uk/info/20122/rubbish_and_recycling_collection_days?addressList={user_uprn}&uprnSubmit=Yes"
+
+        # Make the GET request
+        response = requests.get(URI)
+
+        # Parse the JSON response
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        bin_collection_content = soup.find_all(
+            "div", {"class": "bin-collection-content"}
+        )
+        for content in bin_collection_content:
+            content_left = content.find("div", {"class": "content-left"})
+            content_right = content.find("div", {"class": "content-right"})
+            if content_left and content_right:
+
+                bin_types = content_left.find("h3").text.split(" and ")
+                for bin_type in bin_types:
+
+                    collection_date = datetime.strptime(
+                        content_right.find(
+                            "span", {"class": "nextCollectionDate"}
+                        ).text,
+                        "%A, %d %B %Y",
+                    ).strftime(date_format)
+
+                    dict_data = {
+                        "type": bin_type,
+                        "collectionDate": collection_date,
+                    }
+                    bindata["bins"].append(dict_data)
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/WakefieldCityCouncil.py

@@ -3,6 +3,7 @@ from uk_bin_collection.uk_bin_collection.common import *
 from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
 from datetime import datetime
 
+
 class CouncilClass(AbstractGetBinDataClass):
     """
     Concrete class to scrape bin collection data.
@@ -25,23 +26,23 @@ class CouncilClass(AbstractGetBinDataClass):
             data = {"bins": []}
             # Locate the section with bin collection data
             sections = soup.find_all("div", {"class": "wil_c-content-section_heading"})
-            
+
             for s in sections:
                 if s.get_text(strip=True).lower() == "bin collections":
                     rows = s.find_next_sibling(
                         "div", {"class": "c-content-section_body"}
                     ).find_all("div", class_="tablet:l-col-fb-4 u-mt-10")
-                    
+
                     for row in rows:
                         title_elem = row.find("div", class_="u-mb-4")
                         if title_elem:
                             title = title_elem.get_text(strip=True).capitalize()
-                            
+
                             # Find all collection info in the same section
                             collections = row.find_all("div", class_="u-mb-2")
                             for c in collections:
                                 text = c.get_text(strip=True).lower()
-                                
+
                                 if "next collection" in text:
                                     date_text = text.replace("next collection - ", "")
                                     try:
@@ -51,34 +52,43 @@ class CouncilClass(AbstractGetBinDataClass):
 
                                         dict_data = {
                                             "type": title,
-                                            "collectionDate": next_collection_date
+                                            "collectionDate": next_collection_date,
                                         }
                                         data["bins"].append(dict_data)
                                     except ValueError:
                                         # Skip if the date isn't a valid date
                                         print(f"Skipping invalid date: {date_text}")
-                                    
+
                             # Get future collections
                             future_collections_section = row.find("ul", class_="u-mt-4")
                             if future_collections_section:
-                                future_collections = future_collections_section.find_all("li")
+                                future_collections = (
+                                    future_collections_section.find_all("li")
+                                )
                                 for future_collection in future_collections:
-                                    future_date_text = future_collection.get_text(strip=True)
+                                    future_date_text = future_collection.get_text(
+                                        strip=True
+                                    )
                                     try:
                                         future_collection_date = datetime.strptime(
                                             future_date_text, "%A, %d %B %Y"
                                         ).strftime(date_format)
 
                                         # Avoid duplicates of next collection date
-                                        if future_collection_date != next_collection_date:
+                                        if (
+                                            future_collection_date
+                                            != next_collection_date
+                                        ):
                                             dict_data = {
                                                 "type": title,
-                                                "collectionDate": future_collection_date
+                                                "collectionDate": future_collection_date,
                                             }
                                             data["bins"].append(dict_data)
                                     except ValueError:
                                         # Skip if the future collection date isn't valid
-                                        print(f"Skipping invalid future date: {future_date_text}")
+                                        print(
+                                            f"Skipping invalid future date: {future_date_text}"
+                                        )
 
             # Sort the collections by date
             data["bins"].sort(