uk_bin_collection 0.152.0__py3-none-any.whl → 0.152.2__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/EastleighBoroughCouncil.py

@@ -1,4 +1,8 @@
 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 Select, WebDriverWait
+
 from uk_bin_collection.uk_bin_collection.common import *
 from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
 
@@ -12,59 +16,69 @@ class CouncilClass(AbstractGetBinDataClass):
     """
 
     def parse_data(self, page: str, **kwargs) -> dict:
-        uprn = kwargs.get("uprn")
-        # Check the UPRN is valid
-        check_uprn(uprn)
+        try:
+            uprn = kwargs.get("uprn")
+            # Check the UPRN is valid
+            check_uprn(uprn)
+            headless = kwargs.get("headless")
+            web_driver = kwargs.get("web_driver")
+            url = f"https://www.eastleigh.gov.uk/waste-bins-and-recycling/collection-dates/your-waste-bin-and-recycling-collections?uprn={uprn}"
+            driver = create_webdriver(web_driver, headless, None, __name__)
+            driver.get(url)
 
-        # Request URL
-        url = f"https://www.eastleigh.gov.uk/waste-bins-and-recycling/collection-dates/your-waste-bin-and-recycling-collections?uprn={uprn}"
+            wait = WebDriverWait(driver, 10)
+            bin_content = wait.until(
+                EC.presence_of_element_located((By.CLASS_NAME, "dl-horizontal"))
+            )
 
-        # Make Request
-        requests.packages.urllib3.disable_warnings()
-        page = requests.get(url)
+            # Make a BS4 object from driver's page source
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
 
-        # Make a BS4 object
-        soup = BeautifulSoup(page.text, features="html.parser")
-        soup.prettify()
+            # Data to return
+            data = {"bins": []}
 
-        # Data to return
-        data = {"bins": []}
+            # Valid bin types
+            binTypes = [
+                "Household Waste Bin",
+                "Recycling Bin",
+                "Food Waste Bin",
+                "Glass Box and Batteries",
+                "Garden Waste Bin",
+            ]
 
-        # Valid bin types
-        binTypes = [
-            "Household Waste Bin",
-            "Recycling Bin",
-            "Food Waste Bin",
-            "Glass Box and Batteries",
-            "Garden Waste Bin",
-        ]
+            # Value to create dict for DL values
+            keys, values = [], []
 
-        # Value to create dict for DL values
-        keys, values = [], []
+            # Loop though DT and DD for DL containing bins
+            dl = soup.find("dl", {"class": "dl-horizontal"})
+            for dt in dl.find_all("dt"):
+                keys.append(dt.text.strip())
+            for dd in dl.find_all("dd"):
+                values.append(dd.text.strip())
 
-        # Loop though DT and DD for DL containing bins
-        dl = soup.find("dl", {"class": "dl-horizontal"})
-        for dt in dl.find_all("dt"):
-            keys.append(dt.text.strip())
-        for dd in dl.find_all("dd"):
-            values.append(dd.text.strip())
+            # Create dict for bin name and string dates
+            binDict = dict(zip(keys, values))
 
-        # Create dict for bin name and string dates
-        binDict = dict(zip(keys, values))
+            # Process dict for valid bin types
+            for bin in list(binDict):
+                if bin in binTypes:
+                    if not binDict[bin].startswith("You haven't yet signed up for"):
+                        # Convert date
+                        date = datetime.strptime(binDict[bin], "%a, %d %b %Y")
 
-        # Process dict for valid bin types
-        for bin in list(binDict):
-            if bin in binTypes:
-                if not binDict[bin].startswith("You haven't yet signed up for"):
-                    # Convert date
-                    date = datetime.strptime(binDict[bin], "%a, %d %b %Y")
+                        # Set bin data
+                        dict_data = {
+                            "type": bin,
+                            "collectionDate": date.strftime(date_format),
+                        }
+                        data["bins"].append(dict_data)
 
-                    # Set bin data
-                    dict_data = {
-                        "type": bin,
-                        "collectionDate": date.strftime(date_format),
-                    }
-                    data["bins"].append(dict_data)
+            # Return bin data
+            return data
 
-        # Return bin data
-        return data
+        except Exception as e:
+            print(f"Error fetching/parsing data: {str(e)}")
+            return {"bins": [{"type": "Error", "collectionDate": "2024-01-01"}]}
+        finally:
+            if "driver" in locals():
+                driver.quit()

uk_bin_collection/uk_bin_collection/councils/EnvironmentFirst.py

@@ -1,3 +1,5 @@
+# Legacy script. Copied to Lewes and Eastbourne.
+
 from bs4 import BeautifulSoup
 
 from uk_bin_collection.uk_bin_collection.common import *

uk_bin_collection/uk_bin_collection/councils/EppingForestDistrictCouncil.py

@@ -1,13 +1,15 @@
+from datetime import datetime
+
 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 import webdriver
-from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.support import expected_conditions as EC
-from datetime import datetime
+from selenium.webdriver.support.ui import WebDriverWait
+
+from uk_bin_collection.uk_bin_collection.common import *
 from uk_bin_collection.uk_bin_collection.common import date_format
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
 
 
 class CouncilClass(AbstractGetBinDataClass):
@@ -15,27 +17,57 @@ class CouncilClass(AbstractGetBinDataClass):
         postcode = kwargs.get("postcode", "")
         web_driver = kwargs.get("web_driver")
         headless = kwargs.get("headless")
-
-        options = webdriver.ChromeOptions()
-        if headless:
-            options.add_argument("--headless")
-        driver = create_webdriver(web_driver, headless)
+        data = {"bins": []}
 
         try:
-            driver.get(
-                f"https://eppingforestdc.maps.arcgis.com/apps/instant/lookup/index.html?appid=bfca32b46e2a47cd9c0a84f2d8cdde17&find={postcode}"
+            # Initialize webdriver with logging
+            print(f"Initializing webdriver with: {web_driver}, headless: {headless}")
+            driver = create_webdriver(web_driver, headless, None, __name__)
+
+            # Format and load URL
+            page_url = f"https://eppingforestdc.maps.arcgis.com/apps/instant/lookup/index.html?appid=bfca32b46e2a47cd9c0a84f2d8cdde17&find={postcode}"
+            print(f"Accessing URL: {page_url}")
+            driver.get(page_url)
+
+            # Wait for initial page load
+            wait = WebDriverWait(driver, 20)  # Reduced timeout to fail faster if issues
+
+            # First wait for any loading indicators to disappear
+            try:
+                print("Waiting for loading spinner to disappear...")
+                wait.until(
+                    EC.invisibility_of_element_located(
+                        (By.CSS_SELECTOR, ".esri-widget--loader-container")
+                    )
+                )
+            except Exception as e:
+                print(f"Loading spinner wait failed (may be normal): {str(e)}")
+
+            # Then wait for the content container
+            print("Waiting for content container...")
+            wait.until(
+                EC.presence_of_element_located(
+                    (By.CSS_SELECTOR, ".esri-feature-content")
+                )
             )
-            wait = WebDriverWait(driver, 10)
-            WebDriverWait(driver, 10).until(
+
+            # Finally wait for actual content
+            print("Waiting for content to be visible...")
+            content = wait.until(
                 EC.visibility_of_element_located(
                     (By.CSS_SELECTOR, ".esri-feature-content")
                 )
             )
+
+            # Check if content is actually present
+            if not content:
+                raise ValueError("Content element found but empty")
+
+            print("Content found, getting page source...")
             html_content = driver.page_source
 
             soup = BeautifulSoup(html_content, "html.parser")
             bin_info_divs = soup.select(".esri-feature-content p")
-            data = {"bins": []}
             for div in bin_info_divs:
                 if "collection day is" in div.text:
                     bin_type, date_str = div.text.split(" collection day is ")

uk_bin_collection/uk_bin_collection/councils/GlasgowCityCouncil.py

@@ -14,7 +14,19 @@ class CouncilClass(AbstractGetBinDataClass):
     """
 
     def parse_data(self, page: str, **kwargs) -> dict:
-        # Parse the page
+
+        try:
+            user_uprn = kwargs.get("uprn")
+            check_uprn(user_uprn)
+            url = f"https://onlineservices.glasgow.gov.uk/forms/RefuseAndRecyclingWebApplication/CollectionsCalendar.aspx?UPRN={user_uprn}"
+            if not user_uprn:
+                # This is a fallback for if the user stored a URL in old system. Ensures backwards compatibility.
+                url = kwargs.get("url")
+        except Exception as e:
+            raise ValueError(f"Error getting identifier: {str(e)}")
+
+        # Make a BS4 object
+        page = requests.get(url, verify=False)
         soup = BeautifulSoup(page.text, features="html.parser")
         soup.prettify()
 

uk_bin_collection/uk_bin_collection/councils/GuildfordCouncil.py

@@ -27,9 +27,8 @@ class CouncilClass(AbstractGetBinDataClass):
     def parse_data(self, page: str, **kwargs) -> dict:
         driver = None
         try:
-            uprn = kwargs.get("uprn")
             postcode = kwargs.get("postcode")
-            full_address = kwargs.get("paon")
+            house_number = kwargs.get("paon")
 
             url = "https://my.guildford.gov.uk/customers/s/view-bin-collections"
 
@@ -60,7 +59,7 @@ class CouncilClass(AbstractGetBinDataClass):
                 EC.presence_of_element_located(
                     (
                         By.XPATH,
-                        f"//lightning-base-formatted-text[contains(text(), '{full_address}')]",
+                        f"//lightning-base-formatted-text[contains(text(), '{house_number}')]",
                     )
                 )
             )

uk_bin_collection/uk_bin_collection/councils/HerefordshireCouncil.py

@@ -15,9 +15,20 @@ class CouncilClass(AbstractGetBinDataClass):
     """
 
     def parse_data(self, page: str, **kwargs) -> dict:
+        try:
+            user_uprn = kwargs.get("uprn")
+            check_uprn(user_uprn)
+            url = f"https://www.herefordshire.gov.uk/rubbish-recycling/check-bin-collection-day?blpu_uprn={user_uprn}"
+            if not user_uprn:
+                # This is a fallback for if the user stored a URL in old system. Ensures backwards compatibility.
+                url = kwargs.get("url")
+        except Exception as e:
+            raise ValueError(f"Error getting identifier: {str(e)}")
+
         # Make a BS4 object
-        soup = BeautifulSoup(page.text, features="html.parser")
-        soup.prettify()
+        page = requests.get(url)
+        soup = BeautifulSoup(page.text, "html.parser")
+        soup.prettify
 
         data = {"bins": []}
 

uk_bin_collection/uk_bin_collection/councils/HuntingdonDistrictCouncil.py

@@ -2,10 +2,12 @@
 
 # This script pulls (in one hit) the data from
 # Huntingdon District Council District Council Bins Data
+from datetime import datetime
+
 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 uk_bin_collection.uk_bin_collection.common import date_format
-from datetime import datetime
 
 
 # import the wonderful Beautiful Soup and the URL grabber
@@ -17,9 +19,21 @@ class CouncilClass(AbstractGetBinDataClass):
     """
 
     def parse_data(self, page, **kwargs) -> None:
+
+        try:
+            user_uprn = kwargs.get("uprn")
+            check_uprn(user_uprn)
+            url = f"http://www.huntingdonshire.gov.uk/refuse-calendar/{user_uprn}"
+            if not user_uprn:
+                # This is a fallback for if the user stored a URL in old system. Ensures backwards compatibility.
+                url = kwargs.get("url")
+        except Exception as e:
+            raise ValueError(f"Error getting identifier: {str(e)}")
+
         # Make a BS4 object
-        soup = BeautifulSoup(page.text, features="html.parser")
-        soup.prettify()
+        page = requests.get(url)
+        soup = BeautifulSoup(page.text, "html.parser")
+        soup.prettify
 
         data = {"bins": []}
 

uk_bin_collection/uk_bin_collection/councils/LewesDistrictCouncil.py

@@ -0,0 +1,76 @@
+# Eastbourne uses the same script.
+
+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:
+
+        try:
+            user_uprn = kwargs.get("uprn")
+            check_uprn(user_uprn)
+            url = f"https://environmentfirst.co.uk/house.php?uprn={user_uprn}"
+            if not user_uprn:
+                # This is a fallback for if the user stored a URL in old system. Ensures backwards compatibility.
+                url = kwargs.get("url")
+        except Exception as e:
+            raise ValueError(f"Error getting identifier: {str(e)}")
+
+        # Make a BS4 object
+        page = requests.get(url)
+        soup = BeautifulSoup(page.text, features="html.parser")
+        soup.prettify()
+
+        # Get the paragraph lines from the page
+        data = {"bins": []}
+        page_text = soup.find("div", {"class": "collect"}).find_all("p")
+
+        # Parse the correct lines (find them, remove the ordinal indicator and make them the correct format date) and
+        # then add them to the dictionary
+        rubbish_day = datetime.strptime(
+            remove_ordinal_indicator_from_date_string(
+                page_text[2].find_next("strong").text
+            ),
+            "%d %B %Y",
+        ).strftime(date_format)
+        dict_data = {
+            "type": "Rubbish",
+            "collectionDate": rubbish_day,
+        }
+        data["bins"].append(dict_data)
+        recycling_day = datetime.strptime(
+            remove_ordinal_indicator_from_date_string(
+                page_text[4].find_next("strong").text
+            ),
+            "%d %B %Y",
+        ).strftime(date_format)
+        dict_data = {
+            "type": "Recycling",
+            "collectionDate": recycling_day,
+        }
+        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/LiverpoolCityCouncil.py

@@ -1,7 +1,8 @@
 from bs4 import BeautifulSoup
+from dateutil.relativedelta import relativedelta
+
 from uk_bin_collection.uk_bin_collection.common import *
 from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
-from dateutil.relativedelta import relativedelta
 
 
 # import the wonderful Beautiful Soup and the URL grabber
@@ -18,9 +19,20 @@ class CouncilClass(AbstractGetBinDataClass):
         collections = []
         curr_date = datetime.today()
 
-        # Parse the page
-        soup = BeautifulSoup(page.text, features="html.parser")
-        soup.prettify()
+        try:
+            user_uprn = kwargs.get("uprn")
+            check_uprn(user_uprn)
+            url = f"https://liverpool.gov.uk/Bins/BinDatesTable?UPRN={user_uprn}"
+            if not user_uprn:
+                # This is a fallback for if the user stored a URL in old system. Ensures backwards compatibility.
+                url = kwargs.get("url")
+        except Exception as e:
+            raise ValueError(f"Error getting identifier: {str(e)}")
+
+        # Make a BS4 object
+        page = requests.get(url)
+        soup = BeautifulSoup(page.text, "html.parser")
+        soup.prettify
 
         # Get all table rows on the page - enumerate gives us an index, which is handy for to keep a row count.
         # In this case, the first (0th) row is headings, so we can skip it, then parse the other data.

uk_bin_collection/uk_bin_collection/councils/MaidstoneBoroughCouncil.py

@@ -3,6 +3,7 @@ from datetime import datetime
 
 from bs4 import BeautifulSoup
 from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import Select
 from selenium.webdriver.support.wait import WebDriverWait
@@ -10,8 +11,6 @@ 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
 
-# import the wonderful Beautiful Soup and the URL grabber
-
 
 class CouncilClass(AbstractGetBinDataClass):
     """
@@ -30,7 +29,7 @@ class CouncilClass(AbstractGetBinDataClass):
             web_driver = kwargs.get("web_driver")
             headless = kwargs.get("headless")
             check_postcode(user_postcode)
-            
+
             # Create Selenium webdriver
             driver = create_webdriver(web_driver, headless, None, __name__)
             driver.get(page)
@@ -41,68 +40,64 @@ class CouncilClass(AbstractGetBinDataClass):
             driver.switch_to.frame(iframe_presense)
 
             wait = WebDriverWait(driver, 60)
-            
+
             # Postal code input
             inputElement_postcodesearch = wait.until(
                 EC.element_to_be_clickable((By.NAME, "postcode"))
             )
             inputElement_postcodesearch.send_keys(user_postcode)
-            
-            # Wait for the 'Select address' dropdown to be updated
-            dropdown_select = wait.until(
-                EC.presence_of_element_located((By.XPATH, "//span[contains(text(), 'Select...')]"))
-            )
-            dropdown_select.click()
-            
+
+            time.sleep(5)
+
+            inputElement_postcodesearch.send_keys(Keys.TAB + Keys.DOWN)
+
             dropdown = wait.until(
-                EC.element_to_be_clickable((By.XPATH, f"//div[contains(text(), ' {user_paon}')]"))
+                EC.element_to_be_clickable(
+                    (By.XPATH, f"//div[contains(text(), ' {user_paon}')]")
+                )
             )
             dropdown.click()
 
-            # Wait for 'Searching for...' to be added to page
-            WebDriverWait(driver, timeout=15).until(
+            # This website is horrible!
+            WebDriverWait(driver, 20).until(
                 EC.text_to_be_present_in_element(
-                    (By.CSS_SELECTOR, "span[data-name=html1]"), "Searching"
-                )
-            )
-
-            # Wait for 'Searching for...' to be removed from page
-            WebDriverWait(driver, timeout=15).until(
-                EC.none_of(
-                    EC.text_to_be_present_in_element(
-                        (By.CSS_SELECTOR, "span[data-name=html1]"), "Searching"
-                    )
+                    (By.CSS_SELECTOR, "div.col-collection-panel"), "Next collection"
                 )
             )
 
             # Even then it can still be adding data to the page...
             time.sleep(5)
 
-            soup = BeautifulSoup(driver.page_source, features="html.parser")
-
-            # This is ugly but there is literally no consistency to the HTML
-            def is_a_collection_date(t):
-                return any("Next collection" in c for c in t.children)
-
-            for next_collection in soup.find_all(is_a_collection_date):
-                bin_info = list(
-                    next_collection.parent.select_one("div:nth-child(1)").children
-                )
-                if not bin_info:
-                    continue
-                bin = bin_info[0].get_text()
-                date = next_collection.select_one("strong").get_text(strip=True)
-                bin_date = datetime.strptime(date, "%d %b %Y")
-                dict_data = {
-                    "type": bin,
-                    "collectionDate": bin_date.strftime(date_format),
-                }
-                bin_data["bins"].append(dict_data)
-
-            bin_data["bins"].sort(
-                key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
+            # Scraping via Selenium rather than BeautifulSoup, to ensure eveything's loaded
+            collection_panels = driver.find_elements(
+                By.CSS_SELECTOR, "div.col-collection-panel"
             )
 
+            for panel in collection_panels:
+                try:
+                    # Get bin type (e.g., General waste, Food waste)
+                    bin_type = panel.find_element(
+                        By.CSS_SELECTOR, "h3.collectionDataHeader"
+                    ).text.strip()
+                    # Get next collection date
+                    lines = panel.find_elements(By.CSS_SELECTOR, "ul li")
+                    for line in lines:
+                        if "Next collection" in line.text:
+                            date_str = (
+                                line.text.split("Next collection")[1]
+                                .strip(": ")
+                                .strip()
+                            )
+                            bin_date = datetime.strptime(date_str, "%d/%m/%Y")
+                            bin_data["bins"].append(
+                                {
+                                    "type": bin_type,
+                                    "collectionDate": bin_date.strftime(date_format),
+                                }
+                            )
+                except Exception as inner_e:
+                    print(f"Skipping one panel due to error: {inner_e}")
+
         except Exception as e:
             # Here you can log the exception if needed
             print(f"An error occurred: {e}")

uk_bin_collection/uk_bin_collection/councils/NewhamCouncil.py

@@ -7,14 +7,21 @@ from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataC
 
 class CouncilClass(AbstractGetBinDataClass):
     def parse_data(self, page: str, **kwargs) -> dict:
-        # get the page data
-        http = urllib3.PoolManager()
-        response = http.request("GET", kwargs["url"])
-        page_data = response.data
+
+        try:
+            user_uprn = kwargs.get("uprn")
+            check_uprn(user_uprn)
+            url = f"https://bincollection.newham.gov.uk/Details/Index/{user_uprn}"
+            if not user_uprn:
+                # This is a fallback for if the user stored a URL in old system. Ensures backwards compatibility.
+                url = kwargs.get("url")
+        except Exception as e:
+            raise ValueError(f"Error getting identifier: {str(e)}")
 
         # Make a BS4 object
-        soup = BeautifulSoup(page_data, features="html.parser")
-        soup.prettify()
+        page = requests.get(url)
+        soup = BeautifulSoup(page.text, "html.parser")
+        soup.prettify
 
         # Form a JSON wrapper
         data = {"bins": []}

uk_bin_collection/uk_bin_collection/councils/NorthLincolnshireCouncil.py

@@ -46,7 +46,8 @@ class CouncilClass(AbstractGetBinDataClass):
                     "type": bin_type,
                     "collectionDate": get_next_occurrence_from_day_month(
                         datetime.strptime(
-                            c["BinCollectionDate"].replace(" (*)", "").strip()
+                            remove_ordinal_indicator_from_date_string(
+                                c["BinCollectionDate"].replace(" (*)", "").strip())
                             + " "
                             + datetime.now().strftime("%Y"),
                             "%A %d %B %Y",

uk_bin_collection/uk_bin_collection/councils/NorthSomersetCouncil.py

@@ -43,9 +43,13 @@ class CouncilClass(AbstractGetBinDataClass):
                 collectionDate = (
                     cells[1].get_text(strip=True) + " " + datetime.now().strftime("%Y")
                 )
-                nextCollectionDate = (
-                    cells[2].get_text(strip=True) + " " + datetime.now().strftime("%Y")
-                )
+
+                if len(cells) > 2:
+                    nextCollectionDate = (
+                        cells[2].get_text(strip=True) + " " + datetime.now().strftime("%Y")
+                    )
+                else:
+                    nextCollectionDate = ""
 
                 # Make each Bin element in the JSON
                 dict_data = {
@@ -59,12 +63,13 @@ class CouncilClass(AbstractGetBinDataClass):
                 data["bins"].append(dict_data)
 
                 # Make each next Bin element in the JSON
-                dict_data = {
-                    "type": binType,
-                    "collectionDate": get_next_occurrence_from_day_month(
-                        datetime.strptime(nextCollectionDate, "%A %d %B %Y")
-                    ).strftime(date_format),
-                }
+                if nextCollectionDate != "":
+                    dict_data = {
+                        "type": binType,
+                        "collectionDate": get_next_occurrence_from_day_month(
+                            datetime.strptime(nextCollectionDate, "%A %d %B %Y")
+                        ).strftime(date_format),
+                    }
 
                 # Add data to the main JSON Wrapper
                 data["bins"].append(dict_data)

uk_bin_collection/uk_bin_collection/councils/NorthTynesideCouncil.py

@@ -81,9 +81,9 @@ class CouncilClass(AbstractGetBinDataClass):
         # The regular calendar only shows until end of March 2026, work out how many weeks that is
         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
+        # The garden calendar only shows until end of November 2025, work out how many weeks that is
         garden_weeks_total = math.floor(
-            (datetime(2024, 12, 1) - datetime.now()).days / 7
+            (datetime(2025, 12, 1) - datetime.now()).days / 7
         )
 
         regular_collections, garden_collections, special_collections = [], [], []