uk_bin_collection 0.126.2__tar.gz → 0.127.0__tar.gz

{uk_bin_collection-0.126.2 → uk_bin_collection-0.127.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: uk_bin_collection
-Version: 0.126.2
+Version: 0.127.0
 Summary: Python Lib to collect UK Bin Data
 Author: Robert Bradley
 Author-email: robbrad182@gmail.com

{uk_bin_collection-0.126.2 → uk_bin_collection-0.127.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "uk_bin_collection"
-version = "0.126.2"
+version = "0.127.0"
 description = "Python Lib to collect UK Bin Data"
 readme = "README.md"
 authors = ["Robert Bradley <robbrad182@gmail.com>"]

{uk_bin_collection-0.126.2 → uk_bin_collection-0.127.0}/uk_bin_collection/tests/input.json

@@ -244,6 +244,13 @@
         "wiki_name": "Breckland Council",
         "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
     },
+    "BrentCouncil": {
+        "house_number": "25",
+        "postcode": "HA3 0QU",
+        "url": "https://recyclingservices.brent.gov.uk/waste",
+        "wiki_name": "Brent Council",
+        "wiki_note": "Pass the house number and postcode in their respective parameters."
+    },
     "BrightonandHoveCityCouncil": {
         "house_number": "44 Carden Avenue, Brighton, BN1 8NE",
         "postcode": "BN1 8NE",
@@ -440,7 +447,7 @@
         "uprn": "100110734613",
         "url": "https://www.copeland.gov.uk",
         "wiki_name": "Copeland Borough Council",
-        "wiki_note": "Use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find your UPRN."
+        "wiki_note": "*****This has now been replaced by Cumberland Council****"
     },
     "CornwallCouncil": {
         "skip_get_url": true,
@@ -480,6 +487,12 @@
         "wiki_name": "Croydon Council",
         "wiki_note": "Pass the house number and postcode in their respective parameters."
     },
+    "CumberlandCouncil": {
+        "uprn": "100110734613",
+        "url": "https://waste.cumberland.gov.uk",
+        "wiki_name": "Cumberland Borough Council",
+        "wiki_note": "Use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find your UPRN."
+    },
     "CumberlandAllerdaleCouncil": {
         "house_number": "2",
         "postcode": "CA13 0DE",
@@ -502,6 +515,12 @@
         "wiki_name": "Dartford Borough Council",
         "wiki_note": "Use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find your UPRN."
     },
+    "DenbighshireCouncil": {
+        "url": "https://www.denbighshire.gov.uk/",
+        "uprn": "200004299351",
+        "wiki_name": "Denbighshire Council",
+        "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
+    },
     "DerbyCityCouncil": {
         "url": "https://www.derby.gov.uk",
         "uprn": "10010684240",
@@ -544,6 +563,12 @@
         "wiki_name": "Dudley Council",
         "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
     },
+    "DundeeCityCouncil": {
+        "url": "https://www.dundeecity.gov.uk/",
+        "uprn": "9059043390",
+        "wiki_name": "Dundee City Council",
+        "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
+    },
     "DurhamCouncil": {
         "skip_get_url": true,
         "uprn": "200003218818",
@@ -799,6 +824,12 @@
         "wiki_name": "Guildford Council",
         "wiki_note": "If the bin day is 'today' then the collectionDate will only show today's date if before 7 AM; else the date will be in 'previousCollectionDate'. To get the UPRN, you will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search)."
     },
+    "GwyneddCouncil": {
+        "url": "https://diogel.gwynedd.llyw.cymru",
+        "uprn": "10070350463",
+        "wiki_name": "Gwynedd Council",
+        "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
+    },
     "HackneyCouncil": {
         "house_number": "101",
         "postcode": "N16 9AS",
@@ -930,13 +961,11 @@
         "wiki_note": "Follow the instructions [here](https://waste-services.kingston.gov.uk/waste) until the \"Your bin days\" page, then copy the URL and replace the URL in the command."
     },
     "KirkleesCouncil": {
-        "house_number": "24",
-        "postcode": "HD7 5DX",
+        "uprn": "83002937",
         "skip_get_url": true,
         "url": "https://www.kirklees.gov.uk/beta/your-property-bins-recycling/your-bins",
-        "web_driver": "http://selenium:4444",
         "wiki_name": "Kirklees Council",
-        "wiki_note": "Pass the house number and postcode in their respective parameters. This parser requires a Selenium webdriver."
+        "wiki_note": "Provide your UPRN. Find your UPRN using [FindMyAddress](https://www.findmyaddress.co.uk/search)."
     },
     "KnowsleyMBCouncil": {
         "house_number": "22",
@@ -1319,7 +1348,7 @@
         "house_number": "22",
         "postcode": "NE46 1UQ",
         "skip_get_url": true,
-        "url": "https://www.northumberland.gov.uk/Waste/Bins/Bin-Calendars.aspx",
+        "url": "https://www.northumberland.gov.uk/Waste/Household-waste/Household-bin-collections/Bin-Calendars.aspx",
         "web_driver": "http://selenium:4444",
         "wiki_name": "Northumberland Council",
         "wiki_note": "Pass the house number and postcode in their respective parameters. This parser requires a Selenium webdriver."
@@ -1338,6 +1367,12 @@
         "house_number": "Newdigate Road",
         "wiki_note": "Pass the name of the street ONLY in the house number parameter, wrapped in double quotes. Street name must match exactly as it appears on the council's website."
     },
+    "OadbyAndWigstonBoroughCouncil": {
+        "url": "https://my.oadby-wigston.gov.uk",
+        "uprn": "10010149102",
+        "wiki_name": "Oadby & Wigston Borough Council",
+        "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
+    },
     "OldhamCouncil": {
         "url": "https://portal.oldham.gov.uk/bincollectiondates/details?uprn=422000033556",
         "wiki_name": "Oldham Council",
@@ -1979,6 +2014,12 @@
         "wiki_name": "West Berkshire Council",
         "wiki_note": "Provide your house number in the `house_number` parameter and postcode in the `postcode` parameter."
     },
+    "WestDunbartonshireCouncil": {
+        "url": "https://www.west-dunbarton.gov.uk/",
+        "uprn": "129001383",
+        "wiki_name": "West Dunbartonshire Council",
+        "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
+    },
     "WestLancashireBoroughCouncil": {
         "url": "https://www.westlancs.gov.uk",
         "uprn": "10012343339",

uk_bin_collection-0.127.0/uk_bin_collection/uk_bin_collection/councils/BrentCouncil.py

@@ -0,0 +1,115 @@
+from time import sleep
+
+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:
+        data = {"bins": []}
+        user_postcode = kwargs.get("postcode")
+        user_paon = kwargs.get("paon")
+        check_postcode(user_postcode)
+        check_paon(user_paon)
+
+        URI = "https://recyclingservices.brent.gov.uk/waste"
+
+        payload = {"postcode": user_postcode}
+
+        s = requests.Session()
+
+        # Make the POST request
+        response = s.post(URI, data=payload)
+
+        # Make a BS4 object
+        soup = BeautifulSoup(response.content, features="html.parser")
+
+        address_list = soup.find_all("option")
+
+        current_year = datetime.now().year
+        next_year = current_year + 1
+
+        for address in address_list:
+            if user_paon in (address.text):
+                address_id = address.get("value")
+                URI = f"https://recyclingservices.brent.gov.uk/waste/{address_id}"
+
+                counter = 0
+                r = s.get(URI)
+                while "Loading your bin days..." in r.text:
+                    counter = counter + 1
+                    if counter == 20:
+                        return data
+                    sleep(2)
+                    r = s.get(URI)
+
+                r.raise_for_status()
+
+                soup = BeautifulSoup(r.content, features="html.parser")
+
+                wastecollections = soup.find("div", {"class": "waste__collections"})
+
+                # Find all waste service sections
+                waste_services = wastecollections.find_all(
+                    "h3", class_="govuk-heading-m waste-service-name"
+                )
+
+                for service in waste_services:
+                    # Get the collection type (e.g., Rubbish, Recycling)
+                    collection_type = (service.get_text(strip=True)).split("\n")[0]
+
+                    # Find the sibling container holding details
+                    service_details = service.find_next(
+                        "dl", class_="govuk-summary-list"
+                    )
+
+                    if service_details:
+
+                        # Extract next collection date
+                        next_collection_row = service_details.find(
+                            "dt", string="Next collection"
+                        )
+                        next_collection = (
+                            next_collection_row.find_next_sibling("dd").get_text(
+                                strip=True
+                            )
+                            if next_collection_row
+                            else "Unknown"
+                        )
+
+                        # Parse dates into standard dd/mm/yyyy format
+                        next_collection_date = datetime.strptime(
+                            remove_ordinal_indicator_from_date_string(next_collection),
+                            "%A, %d %B",
+                        )
+
+                        if (datetime.now().month == 12) and (
+                            next_collection.month == 1
+                        ):
+                            next_collection_date = next_collection_date.replace(
+                                year=next_year
+                            )
+                        else:
+                            next_collection_date = next_collection_date.replace(
+                                year=current_year
+                            )
+
+                        dict_data = {
+                            "type": collection_type.strip(),
+                            "collectionDate": next_collection_date.strftime(
+                                date_format
+                            ),
+                        }
+                        data["bins"].append(dict_data)
+
+        return data

{uk_bin_collection-0.126.2 → uk_bin_collection-0.127.0}/uk_bin_collection/uk_bin_collection/councils/CornwallCouncil.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
@@ -52,9 +53,13 @@ class CouncilClass(AbstractGetBinDataClass):
 
         for item in soup.find_all("div", class_="collection text-center service"):
             bin_type = item.contents[1].text + " bin"
-            collection_date = datetime.strptime(item.contents[5].text, "%d %b").replace(
-                year=curr_date.year
-            )
+            try:
+                collection_date = datetime.strptime(
+                    item.contents[5].text, "%d %b"
+                ).replace(year=curr_date.year)
+            except:
+                continue
+
             if curr_date.month == 12 and collection_date.month == 1:
                 collection_date = collection_date + relativedelta(years=1)
             collections.append((bin_type, collection_date))

uk_bin_collection-0.127.0/uk_bin_collection/uk_bin_collection/councils/CumberlandCouncil.py

@@ -0,0 +1,96 @@
+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://waste.cumberland.gov.uk/renderform?t=25&k=E43CEB1FB59F859833EF2D52B16F3F4EBE1CAB6A"
+
+        s = requests.Session()
+
+        # Make the GET request
+        response = s.get(URI)
+
+        # Make a BS4 object
+        soup = BeautifulSoup(response.content, features="html.parser")
+
+        # print(soup)
+
+        token = (soup.find("input", {"name": "__RequestVerificationToken"})).get(
+            "value"
+        )
+
+        formguid = (soup.find("input", {"name": "FormGuid"})).get("value")
+
+        # print(token)
+        # print(formguid)
+
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Origin": "https://waste.cumberland.gov.uk",
+            "Referer": "https://waste.cumberland.gov.uk/renderform?t=25&k=E43CEB1FB59F859833EF2D52B16F3F4EBE1CAB6A",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36 OPR/98.0.0.0",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+
+        payload = {
+            "__RequestVerificationToken": token,
+            "FormGuid": formguid,
+            "ObjectTemplateID": "25",
+            "Trigger": "submit",
+            "CurrentSectionID": "33",
+            "TriggerCtl": "",
+            "FF265": f"U{user_uprn}",
+            "FF265lbltxt": "Please select your address",
+        }
+
+        # print(payload)
+
+        response = s.post(
+            "https://waste.cumberland.gov.uk/renderform/Form",
+            headers=headers,
+            data=payload,
+        )
+
+        soup = BeautifulSoup(response.content, features="html.parser")
+        for row in soup.find_all("div", class_="resirow"):
+            # Extract the type of collection (e.g., Recycling, Refuse)
+            collection_type_div = row.find("div", class_="col")
+            collection_type = (
+                collection_type_div.get("class")[1]
+                if collection_type_div
+                else "Unknown"
+            )
+
+            # Extract the collection date
+            date_div = row.find("div", style="width:360px;")
+            collection_date = date_div.text.strip() if date_div else "Unknown"
+
+            dict_data = {
+                "type": collection_type,
+                "collectionDate": datetime.strptime(
+                    collection_date, "%A %d %B %Y"
+                ).strftime(date_format),
+            }
+            bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection-0.127.0/uk_bin_collection/uk_bin_collection/councils/DenbighshireCouncil.py

@@ -0,0 +1,66 @@
+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_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = "https://refusecalendarapi.denbighshire.gov.uk/Csrf/token"
+
+        token = requests.get(URI)
+
+        token_data = token.json()
+
+        URI = f"https://refusecalendarapi.denbighshire.gov.uk/Calendar/{user_uprn}"
+
+        headers = {
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            "content-type": "application/json",
+            "dnt": "1",
+            "host": "refusecalendarapi.denbighshire.gov.uk",
+            "referer": "https://refusecalendarapi.denbighshire.gov.uk/",
+            "x-csrf-token": token_data["token"],
+        }
+
+        # Make the GET request
+        response = requests.get(URI, headers=headers)
+
+        # Parse the JSON response
+        json_data = response.json()
+
+        bin_types = {
+            "refuseDate": "Refuse",
+            "recyclingDate": "Recycling",
+            "gardenDate": "Garden Waste",
+            "ahpDate": "AHP (Assisted Household Pickup)",
+            "tradeDate": "Trade Waste",
+            "tradeRefuseDate": "Trade Refuse",
+            "tradeRecyclingDate": "Trade Recycling",
+        }
+
+        bindata["bins"] = [
+            {"type": label, "collectionDate": json_data[key]}
+            for key, label in bin_types.items()
+            if json_data.get(key)
+        ]
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection-0.127.0/uk_bin_collection/uk_bin_collection/councils/DundeeCityCouncil.py

@@ -0,0 +1,44 @@
+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_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = f"https://www.dundee-mybins.co.uk/get_calendar.php?rn={user_uprn}"
+
+        # Make the GET request
+        response = requests.get(URI)
+
+        # Parse the JSON response
+        bin_collection = response.json()
+
+        for item in bin_collection:
+            dict_data = {
+                "type": item["title"],
+                "collectionDate": datetime.strptime(item["start"], "%Y-%m-%d").strftime(
+                    date_format
+                ),
+            }
+            bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection-0.127.0/uk_bin_collection/uk_bin_collection/councils/GwyneddCouncil.py

@@ -0,0 +1,54 @@
+import requests
+from bs4 import BeautifulSoup, Tag
+
+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://diogel.gwynedd.llyw.cymru/Daearyddol/en/LleDwinByw/Index/{user_uprn}"
+
+        # Make the GET request
+        response = requests.get(URI)
+
+        soup = BeautifulSoup(response.text, "html.parser")
+        collections_headline = soup.find("h6", text="Next collection dates:")
+        if not isinstance(collections_headline, Tag):
+            raise Exception("Could not find collections")
+        collections = collections_headline.find_next("ul").find_all("li")
+
+        for collection in collections:
+            if not isinstance(collection, Tag):
+                continue
+            for p in collection.find_all("p"):
+                p.extract()
+
+            bin_type, date_str = collection.text.strip().split(":")[:2]
+            bin_type, date_str = bin_type.strip(), date_str.strip()
+
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": datetime.strptime(date_str, "%A %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-0.127.0/uk_bin_collection/uk_bin_collection/councils/KirkleesCouncil.py

@@ -0,0 +1,76 @@
+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_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        SESSION_URL = "https://my.kirklees.gov.uk/authapi/isauthenticated?uri=https%253A%252F%252Fmy.kirklees.gov.uk%252Fservice%252FBins_and_recycling___Manage_your_bins&hostname=my.kirklees.gov.uk&withCredentials=true"
+
+        API_URL = "https://my.kirklees.gov.uk/apibroker/runLookup"
+
+        data = {
+            "formValues": {"Search": {"validatedUPRN": {"value": user_uprn}}},
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://my.kirklees.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": "65e08e60b299d",
+            "repeat_against": "",
+            "noRetry": "false",
+            "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"]
+        if not isinstance(rows_data, dict):
+            raise ValueError("Invalid data returned from API")
+
+        for bin_id, bin_info in rows_data.items():
+            label = bin_info.get("label", "Unknown")
+            next_collection_date = bin_info.get("NextCollectionDate", "Unknown")
+            # Convert the date string into a readable format
+            try:
+                formatted_date = datetime.strptime(
+                    next_collection_date, "%Y-%m-%dT%H:%M:%S"
+                ).strftime(date_format)
+            except ValueError:
+                formatted_date = "Unknown"
+
+            dict_data = {"type": label, "collectionDate": formatted_date}
+            bindata["bins"].append(dict_data)
+
+        return bindata

{uk_bin_collection-0.126.2 → uk_bin_collection-0.127.0}/uk_bin_collection/uk_bin_collection/councils/LondonBoroughSutton.py

@@ -61,7 +61,7 @@ class CouncilClass(AbstractGetBinDataClass):
                 "%A, %d %B",
             )
 
-            if next_collection.month == 1:
+            if (datetime.now().month == 12) and (next_collection.month == 1):
                 next_collection = next_collection.replace(year=next_year)
             else:
                 next_collection = next_collection.replace(year=current_year)

{uk_bin_collection-0.126.2 → uk_bin_collection-0.127.0}/uk_bin_collection/uk_bin_collection/councils/NorthumberlandCouncil.py

@@ -27,7 +27,7 @@ class CouncilClass(AbstractGetBinDataClass):
     def parse_data(self, page: str, **kwargs) -> dict:
         driver = None
         try:
-            page = "https://www.northumberland.gov.uk/Waste/Bins/Bin-Calendars.aspx"
+            page = "https://www.northumberland.gov.uk/Waste/Household-waste/Household-bin-collections/Bin-Calendars.aspx"
 
             data = {"bins": []}
 
@@ -74,7 +74,7 @@ class CouncilClass(AbstractGetBinDataClass):
                         "span",
                         id="p_lt_ctl04_pageplaceholder_p_lt_ctl02_WasteCollectionCalendars_spanRouteSummary",
                     )
-                    .string.replace("Routes found: ", "")
+                    .text.replace("Routes found: ", "")
                     .split(","),
                 )
             )
@@ -82,6 +82,8 @@ class CouncilClass(AbstractGetBinDataClass):
             # Get the background colour for each of them...
             bins_by_colours = dict()
             for bin in bins_collected:
+                if "(but no dates found)" in bin:
+                    continue
                 style_str = soup.find("span", string=bin)["style"]
                 bin_colour = self.extract_styles(style_str)["background-color"].upper()
                 bins_by_colours[bin_colour] = bin