uk_bin_collection 0.121.0__tar.gz → 0.122.0__tar.gz

{uk_bin_collection-0.121.0 → uk_bin_collection-0.122.0}/PKG-INFO

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

{uk_bin_collection-0.121.0 → uk_bin_collection-0.122.0}/pyproject.toml

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

{uk_bin_collection-0.121.0 → uk_bin_collection-0.122.0}/uk_bin_collection/tests/input.json

@@ -871,6 +871,12 @@
         "wiki_name": "High Peak Council",
         "wiki_note": "Pass the name of the street with the house number parameter, wrapped in double quotes. This parser requires a Selenium webdriver."
     },
+    "HinckleyandBosworthBoroughCouncil": {
+        "url": "https://www.hinckley-bosworth.gov.uk",
+        "uprn": "100030533512",
+        "wiki_name": "Hinckley and Bosworth Borough Council",
+        "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
+    },
     "HounslowCouncil": {
         "house_number": "17A LAMPTON PARK ROAD, HOUNSLOW",
         "postcode": "TW3 4HS",
@@ -1072,7 +1078,7 @@
         "wiki_note": "Pass the UPRN. You can find it using [FindMyAddress](https://www.findmyaddress.co.uk/search)."
     },
     "MertonCouncil": {
-        "url": "https://myneighbourhood.merton.gov.uk/wasteservices/WasteServices.aspx?ID=25851371",
+        "url": "https://myneighbourhood.merton.gov.uk/wasteservices/WasteServices.aspx?ID=25936129",
         "wiki_command_url_override": "https://myneighbourhood.merton.gov.uk/Wasteservices/WasteServices.aspx?ID=XXXXXXXX",
         "wiki_name": "Merton Council",
         "wiki_note": "Follow the instructions [here](https://myneighbourhood.merton.gov.uk/Wasteservices/WasteServicesSearch.aspx) until you get the \"Your recycling and rubbish collection days\" page, then copy the URL and replace the URL in the command."
@@ -1132,6 +1138,12 @@
         "wiki_name": "Mole Valley District Council",
         "wiki_note": "UPRN can only be parsed with a valid postcode."
     },
+    "MonmouthshireCountyCouncil": {
+        "url": "https://maps.monmouthshire.gov.uk",
+        "uprn": "100100266220",
+        "wiki_name": "Monmouthshire County Council",
+        "wiki_note": "You will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search) to find the UPRN."
+    },
     "MorayCouncil": {
         "uprn": "28841",
         "url": "https://bindayfinder.moray.gov.uk/",

{uk_bin_collection-0.121.0 → uk_bin_collection-0.122.0}/uk_bin_collection/uk_bin_collection/councils/BlabyDistrictCouncil.py

@@ -31,11 +31,14 @@ class CouncilClass(AbstractGetBinDataClass):
         for container in soup.find_all(class_="box-item"):
 
             # Get the next collection dates from the <p> tag containing <strong>
-            dates_tag = (
-                container.find("p", string=lambda text: "Next" in text)
-                .find_next("p")
-                .find("strong")
-            )
+            try:
+                dates_tag = (
+                    container.find("p", string=lambda text: "Next" in text)
+                    .find_next("p")
+                    .find("strong")
+                )
+            except:
+                continue
             collection_dates = (
                 dates_tag.text.strip().split(", and then ")
                 if dates_tag

{uk_bin_collection-0.121.0 → uk_bin_collection-0.122.0}/uk_bin_collection/uk_bin_collection/councils/BlackburnCouncil.py

@@ -67,11 +67,19 @@ class CouncilClass(AbstractGetBinDataClass):
                 for collection in bin_collections:
                     if collection is not None:
                         bin_type = collection[0].get("BinType")
+                        current_collection_date = collection[0].get("CollectionDate")
+                        if current_collection_date is None:
+                            continue
                         current_collection_date = datetime.strptime(
-                            collection[0].get("CollectionDate"), "%Y-%m-%d"
+                            current_collection_date, "%Y-%m-%d"
                         )
+                        next_collection_date = collection[0].get(
+                            "NextScheduledCollectionDate"
+                        )
+                        if next_collection_date is None:
+                            continue
                         next_collection_date = datetime.strptime(
-                            collection[0].get("NextScheduledCollectionDate"), "%Y-%m-%d"
+                            next_collection_date, "%Y-%m-%d"
                         )
 
                         # Work out the most recent collection date to display

{uk_bin_collection-0.121.0 → uk_bin_collection-0.122.0}/uk_bin_collection/uk_bin_collection/councils/CarmarthenshireCountyCouncil.py

@@ -34,10 +34,10 @@ class CouncilClass(AbstractGetBinDataClass):
 
             # Find the next collection date
             date_tag = container.find(class_="font11 text-center")
-            if date_tag:
-                collection_date = date_tag.text.strip()
-            else:
+            if date_tag.text.strip() == "":
                 continue
+            else:
+                collection_date = date_tag.text.strip()
 
             dict_data = {
                 "type": bin_type,

{uk_bin_collection-0.121.0 → uk_bin_collection-0.122.0}/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-0.121.0 → uk_bin_collection-0.122.0}/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-0.122.0/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-0.122.0/uk_bin_collection/uk_bin_collection/councils/LondonBoroughLewisham.py

@@ -0,0 +1,140 @@
+import re
+import time
+
+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
+
+
+# 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")
+        user_postcode = kwargs.get("postcode")
+        web_driver = kwargs.get("web_driver")
+        headless = kwargs.get("headless")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        # Initialize the WebDriver (Chrome in this case)
+        with create_webdriver(
+            web_driver,
+            headless,
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
+            __name__,
+        ) as driver:
+
+            # Step 1: Navigate to the form page
+            driver.get(
+                "https://lewisham.gov.uk/myservices/recycling-and-rubbish/your-bins/collection"
+            )
+
+            try:
+                cookie_accept_button = WebDriverWait(driver, 5).until(
+                    EC.element_to_be_clickable(
+                        (By.ID, "CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll")
+                    )
+                )
+                cookie_accept_button.click()
+            except Exception:
+                print("No cookie consent banner found or already dismissed.")
+
+            # Wait for the form to load
+            WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located((By.CLASS_NAME, "address-finder"))
+            )
+
+            # Step 2: Locate the input field for the postcode
+            postcode_input = driver.find_element(
+                By.CLASS_NAME, "js-address-finder-input"
+            )
+
+            # Enter the postcode
+            postcode_input.send_keys(
+                user_postcode
+            )  # Replace with your desired postcode
+            time.sleep(1)  # Optional: Wait for the UI to react
+
+            # Step 4: Click the "Find address" button with retry logic
+            find_button = WebDriverWait(driver, 10).until(
+                EC.element_to_be_clickable(
+                    (By.CLASS_NAME, "js-address-finder-step-address")
+                )
+            )
+            find_button.click()
+
+            # Wait for the address selector to appear and options to load
+            WebDriverWait(driver, 10).until(
+                lambda d: len(
+                    d.find_element(By.ID, "address-selector").find_elements(
+                        By.TAG_NAME, "option"
+                    )
+                )
+                > 1
+            )
+
+            # Select the dropdown and print available options
+            address_selector = driver.find_element(By.ID, "address-selector")
+
+            # Use Select class to interact with the dropdown
+            select = Select(address_selector)
+            if len(select.options) > 1:
+                select.select_by_value(user_uprn)
+            else:
+                print("No additional addresses available to select")
+
+            # Wait until the URL contains the expected substring
+            WebDriverWait(driver, 10).until(
+                EC.url_contains("/find-your-collection-day-result")
+            )
+
+            # Parse the HTML
+            soup = BeautifulSoup(driver.page_source, "html.parser")
+
+            # Extract the main container
+            collection_result = soup.find("div", class_="js-find-collection-result")
+
+            # Extract each collection type and its frequency/day
+            for strong_tag in collection_result.find_all("strong"):
+                bin_type = strong_tag.text.strip()  # e.g., "Food waste"
+                # Extract the sibling text
+                schedule_text = (
+                    strong_tag.next_sibling.next_sibling.next_sibling.text.strip()
+                    .replace("\n", " ")
+                    .replace("\t", " ")
+                )
+
+                # Extract the day using regex
+                print(schedule_text)
+                day_match = re.search(r"on\s*(\w+day)", schedule_text)
+                print(day_match)
+                day = day_match.group(1) if day_match else None
+
+                # Extract the next collection date using regex
+                date_match = re.search(
+                    r"Your next collection date is\s*(\d{2}/\d{2}/\d{4})(.?)",
+                    schedule_text,
+                )
+                if date_match:
+                    next_collection_date = date_match.group(1)
+                else:
+                    next_collection_date = get_next_day_of_week(day, date_format)
+
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": next_collection_date,
+                }
+                bindata["bins"].append(dict_data)
+
+            return bindata

uk_bin_collection-0.122.0/uk_bin_collection/uk_bin_collection/councils/MonmouthshireCountyCouncil.py

@@ -0,0 +1,70 @@
+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://maps.monmouthshire.gov.uk/?action=SetAddress&UniqueId={user_uprn}"
+        )
+
+        # Make the GET request
+        response = requests.get(URI)
+
+        # Parse the HTML
+        soup = BeautifulSoup(response.content, "html.parser")
+
+        waste_collections_div = soup.find("div", {"aria-label": "Waste Collections"})
+
+        # Find all bin collection panels
+        bin_panels = waste_collections_div.find_all("div", class_="atPanelContent")
+
+        current_year = datetime.now().year
+        current_month = datetime.now().month
+
+        for panel in bin_panels:
+            # Extract bin name (e.g., "Household rubbish bag")
+            bin_name = panel.find("h4").text.strip().replace("\r", "").replace("\n", "")
+
+            # Extract collection date (e.g., "Monday 9th December")
+            date_tag = panel.find("p")
+            if date_tag and "Your next collection date is" in date_tag.text:
+                collection_date = date_tag.find("strong").text.strip()
+            else:
+                continue
+
+            collection_date = datetime.strptime(
+                remove_ordinal_indicator_from_date_string(collection_date), "%A %d %B"
+            )
+
+            if (current_month > 9) and (collection_date.month < 4):
+                collection_date = collection_date.replace(year=(current_year + 1))
+            else:
+                collection_date = collection_date.replace(year=current_year)
+
+            dict_data = {
+                "type": bin_name,
+                "collectionDate": collection_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-0.122.0/uk_bin_collection/uk_bin_collection/councils/WarwickDistrictCouncil.py

@@ -0,0 +1,53 @@
+# This script pulls (in one hit) the data
+# from Warick 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
+
+
+# import the wonderful Beautiful Soup and the URL grabber
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    baseclass. They can also override some
+    operations with a default implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+        # Make a BS4 object
+        soup = BeautifulSoup(page.text, features="html.parser")
+        soup.prettify()
+
+        data = {"bins": []}
+
+        # Find all bin panels
+        bin_panels = soup.find_all("div", class_="col-sm-4 col-lg-3")
+
+        # Iterate through each panel to extract information
+        for panel in bin_panels:
+            bin_type = panel.find("img")["alt"].strip()
+
+            waste_dates = panel.find(
+                "div", class_="col-xs-12 text-center waste-dates margin-bottom-15"
+            )
+
+            for p in waste_dates.find_all("p")[1:]:
+                date = p.text.strip()
+                if " " in date:
+                    date = date.split(" ")[1]
+
+                dict_data = {
+                    "type": bin_type,
+                    "collectionDate": date,
+                }
+                data["bins"].append(dict_data)
+
+        data["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
+        )
+
+        return data

uk_bin_collection-0.121.0/uk_bin_collection/uk_bin_collection/councils/LondonBoroughLewisham.py

@@ -1,132 +0,0 @@
-import time
-
-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
-
-
-# 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")
-        user_postcode = kwargs.get("postcode")
-        web_driver = kwargs.get("web_driver")
-        headless = kwargs.get("headless")
-        check_uprn(user_uprn)
-        bindata = {"bins": []}
-
-        # Initialize the WebDriver (Chrome in this case)
-        driver = create_webdriver(
-            web_driver,
-            headless,
-            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
-            __name__,
-        )
-
-        # Step 1: Navigate to the form page
-        driver.get(
-            "https://lewisham.gov.uk/myservices/recycling-and-rubbish/your-bins/collection"
-        )
-
-        try:
-            cookie_accept_button = WebDriverWait(driver, 5).until(
-                EC.element_to_be_clickable(
-                    (By.ID, "CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll")
-                )
-            )
-            cookie_accept_button.click()
-        except Exception:
-            print("No cookie consent banner found or already dismissed.")
-
-        # Wait for the form to load
-        WebDriverWait(driver, 10).until(
-            EC.presence_of_element_located((By.CLASS_NAME, "address-finder"))
-        )
-
-        # Step 2: Locate the input field for the postcode
-        postcode_input = driver.find_element(By.CLASS_NAME, "js-address-finder-input")
-
-        # Enter the postcode
-        postcode_input.send_keys(user_postcode)  # Replace with your desired postcode
-        time.sleep(1)  # Optional: Wait for the UI to react
-
-        # Step 4: Click the "Find address" button with retry logic
-        find_button = WebDriverWait(driver, 10).until(
-            EC.element_to_be_clickable(
-                (By.CLASS_NAME, "js-address-finder-step-address")
-            )
-        )
-        find_button.click()
-
-        # Wait for the address selector to appear and options to load
-        WebDriverWait(driver, 10).until(
-            lambda d: len(
-                d.find_element(By.ID, "address-selector").find_elements(
-                    By.TAG_NAME, "option"
-                )
-            )
-            > 1
-        )
-
-        # Select the dropdown and print available options
-        address_selector = driver.find_element(By.ID, "address-selector")
-
-        # Use Select class to interact with the dropdown
-        select = Select(address_selector)
-        if len(select.options) > 1:
-            select.select_by_value(user_uprn)
-        else:
-            print("No additional addresses available to select")
-
-        # Wait until the URL contains the expected substring
-        WebDriverWait(driver, 10).until(
-            EC.url_contains("/find-your-collection-day-result")
-        )
-
-        # Parse the HTML
-        soup = BeautifulSoup(driver.page_source, "html.parser")
-
-        # Extract the main container
-        collection_result = soup.find("div", class_="js-find-collection-result")
-
-        # Extract each collection type and its frequency/day
-        for strong_tag in collection_result.find_all("strong"):
-            bin_type = strong_tag.text.strip()  # e.g., "Food waste"
-            # Extract day from the sibling text
-            schedule_text = (
-                strong_tag.next_sibling.next_sibling.next_sibling.text.strip()
-                .split("on\n")[-1]
-                .replace("\n", "")
-                .replace("\t", "")
-            )
-            day = schedule_text.strip().split(".")[0]
-
-            # Extract the next collection date
-            if "Your next collection date is" in schedule_text:
-                start_index = schedule_text.index("Your next collection date is") + len(
-                    "Your next collection date is"
-                )
-                next_collection_date = (
-                    schedule_text[start_index:].strip().split("\n")[0].strip()
-                )
-            else:
-                next_collection_date = get_next_day_of_week(day, date_format)
-
-            dict_data = {
-                "type": bin_type,
-                "collectionDate": next_collection_date,
-            }
-            bindata["bins"].append(dict_data)
-
-        return bindata

uk_bin_collection-0.121.0/uk_bin_collection/uk_bin_collection/councils/WarwickDistrictCouncil.py

@@ -1,34 +0,0 @@
-# This script pulls (in one hit) the data
-# from Warick District Council Bins Data
-
-from bs4 import BeautifulSoup
-from uk_bin_collection.uk_bin_collection.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
-    baseclass. They can also override some
-    operations with a default implementation.
-    """
-
-    def parse_data(self, page: str, **kwargs) -> dict:
-        # Make a BS4 object
-        soup = BeautifulSoup(page.text, features="html.parser")
-        soup.prettify()
-
-        data = {"bins": []}
-
-        for element in soup.find_all("strong"):
-            bin_type = element.next_element
-            bin_type = bin_type.lstrip()
-            collectionDateElement = element.next_sibling.next_element.next_element
-            collectionDate = collectionDateElement.getText()
-            dict_data = {
-                "type": bin_type,
-                "collectionDate": collectionDate,
-            }
-            data["bins"].append(dict_data)
-
-        return data