uk_bin_collection 0.152.11__tar.gz → 0.153.0__tar.gz

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/PKG-INFO

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

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/pyproject.toml

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

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/tests/input.json

@@ -253,7 +253,7 @@
         "postcode": "BL1 5PQ",
         "skip_get_url": true,
         "uprn": "100010886936",
-        "url": "https://carehomes.bolton.gov.uk/bins.aspx",
+        "url": "https://web.bolton.gov.uk/bins.aspx",
         "web_driver": "http://selenium:4444",
         "wiki_name": "Bolton",
         "wiki_note": "To get the UPRN, you will need to use [FindMyAddress](https://www.findmyaddress.co.uk/search). Previously required a single field that was UPRN and full address; now requires UPRN and postcode as separate fields.",
@@ -377,13 +377,10 @@
         "LAD24CD": "E07000172"
     },
     "BuckinghamshireCouncil": {
-        "house_number": "The Ridings, Magpie Lane, Loudwater, High Wycombe, HP13 7BA",
-        "postcode": "HP13 7BA",
         "uprn": "100081093078",
         "url": "https://www.buckinghamshire.gov.uk/waste-and-recycling/find-out-when-its-your-bin-collection/",
-        "web_driver": "http://selenium:4444",
         "wiki_name": "Buckinghamshire",
-        "wiki_note": "Pass the house name/number and postcode in their respective arguments, both wrapped in quotes.",
+        "wiki_note": "Pass the UPRN. You can find it using [FindMyAddress](https://www.findmyaddress.co.uk/search).",
         "LAD24CD": "E06000060"
     },
     "BurnleyBoroughCouncil": {
@@ -1446,7 +1443,7 @@
         "house_number": "71",
         "postcode": "ME16 8BT",
         "url": "https://my.maidstone.gov.uk/service/Find-your-bin-day",
-        "web_driver": "http://selenium:4444", 
+        "web_driver": "http://selenium:4444",
         "wiki_name": "Maidstone",
         "wiki_note": "Pass the house number and postcode in their respective parameters. This parser requires a Selenium webdriver.",
         "LAD24CD": "E07000110"

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/BoltonCouncil.py

@@ -35,7 +35,7 @@ class CouncilClass(AbstractGetBinDataClass):
             data = {"bins": []}
 
             # Get our initial session running
-            page = "https://carehomes.bolton.gov.uk/bins.aspx"
+            page = "https://web.bolton.gov.uk/bins.aspx"
 
             driver = create_webdriver(web_driver, headless, None, __name__)
             driver.get(page)

uk_bin_collection-0.153.0/uk_bin_collection/uk_bin_collection/councils/BuckinghamshireCouncil.py

@@ -0,0 +1,101 @@
+import json
+from dataclasses import asdict, dataclass
+from typing import Literal
+
+import requests
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+from uk_bin_collection.uk_bin_collection.common import check_uprn
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+key_hex = "F57E76482EE3DC3336495DEDEEF3962671B054FE353E815145E29C5689F72FEC"
+iv_hex = "2CBF4FC35C69B82362D393A4F0B9971A"
+
+
+@dataclass
+class BucksInput:
+    P_CLIENT_ID: Literal[152]
+    P_COUNCIL_ID: Literal[34505]
+    P_LANG_CODE: Literal["EN"]
+    P_UPRN: str
+
+
+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 encode_body(self, bucks_input: BucksInput):
+        key = bytes.fromhex(key_hex)
+        iv = bytes.fromhex(iv_hex)
+
+        json_data = json.dumps(asdict(bucks_input))
+        data_bytes = json_data.encode("utf-8")
+
+        padder = padding.PKCS7(128).padder()
+        padded_data = padder.update(data_bytes) + padder.finalize()
+
+        backend = default_backend()
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
+        encryptor = cipher.encryptor()
+        ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+
+        return ciphertext.hex()
+
+    def decode_response(self, hex_input: str):
+
+        key = bytes.fromhex(key_hex)
+        iv = bytes.fromhex(iv_hex)
+        ciphertext = bytes.fromhex(hex_input)
+
+        backend = default_backend()
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
+        decryptor = cipher.decryptor()
+        decrypted_padded = decryptor.update(ciphertext) + decryptor.finalize()
+
+        unpadder = padding.PKCS7(128).unpadder()
+        plaintext_bytes = unpadder.update(decrypted_padded) + unpadder.finalize()
+        plaintext = plaintext_bytes.decode("utf-8")
+
+        return json.loads(plaintext)
+
+    def parse_data(self, _: str, **kwargs) -> dict:
+        try:
+            user_uprn: str = kwargs.get("uprn") or ""
+            check_uprn(user_uprn)
+            bucks_input = BucksInput(
+                P_CLIENT_ID=152, P_COUNCIL_ID=34505, P_LANG_CODE="EN", P_UPRN=user_uprn
+            )
+
+            encoded_input = self.encode_body(bucks_input)
+
+            session = requests.Session()
+            response = session.post(
+                "https://itouchvision.app/portal/itouchvision/kmbd/collectionDay",
+                data=encoded_input,
+            )
+
+            output = response.text
+
+            decoded_bins = self.decode_response(output)
+            data: dict[str, list[dict[str, str]]] = {}
+            data["bins"] = list(
+                map(
+                    lambda a: {
+                        "type": a["binType"],
+                        "collectionDate": a["collectionDay"].replace("-", "/"),
+                    },
+                    decoded_bins["collectionDay"],
+                )
+            )
+
+        except Exception as e:
+            # Here you can log the exception if needed
+            print(f"An error occurred: {e}")
+            # Optionally, re-raise the exception if you want it to propagate
+            raise
+        return data

uk_bin_collection-0.153.0/uk_bin_collection/uk_bin_collection/councils/EastHertsCouncil.py

@@ -0,0 +1,99 @@
+import time
+
+import requests
+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
+
+
+# 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:
+        # Make a BS4 object
+        uprn = kwargs.get("uprn")
+        # usrn = kwargs.get("paon")
+        check_uprn(uprn)
+        # check_usrn(usrn)
+        bindata = {"bins": []}
+
+        # uprn = uprn.zfill(12)
+
+        SESSION_URL = "https://eastherts-self.achieveservice.com/authapi/isauthenticated?uri=https%253A%252F%252Feastherts-self.achieveservice.com%252FAchieveForms%252F%253Fmode%253Dfill%2526consentMessage%253Dyes%2526form_uri%253Dsandbox-publish%253A%252F%252FAF-Process-98782935-6101-4962-9a55-5923e76057b6%252FAF-Stage-dcd0ec18-dfb4-496a-a266-bd8fadaa28a7%252Fdefinition.json%2526process%253D1%2526process_uri%253Dsandbox-processes%253A%252F%252FAF-Process-98782935-6101-4962-9a55-5923e76057b6%2526process_id%253DAF-Process-98782935-6101-4962-9a55-5923e76057b6&hostname=eastherts-self.achieveservice.com&withCredentials=true"
+
+        API_URL = "https://eastherts-self.achieveservice.com/apibroker/runLookup"
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "*/*",
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://eastherts-self.achieveservice.com/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 = {
+            # unix_timestamp
+            "_": str(int(time.time() * 1000)),
+            "sid": sid,
+        }
+
+        params = {
+            "id": "683d9ff0e299d",
+            "repeat_against": "",
+            "noRetry": "true",
+            "getOnlyTokens": "undefined",
+            "log_id": "",
+            "app_name": "AF-Renderer::Self",
+            # unix_timestamp
+            "_": str(int(time.time() * 1000)),
+            "sid": sid,
+        }
+
+        data = {
+            "formValues": {
+                "Collection Days": {
+                    "inputUPRN": {
+                        "value": uprn,
+                    }
+                },
+            }
+        }
+
+        r = s.post(API_URL, json=data, headers=headers, params=params)
+        r.raise_for_status()
+
+        data = r.json()
+        rows_data = data["integration"]["transformed"]["rows_data"]["0"]
+        if not isinstance(rows_data, dict):
+            raise ValueError("Invalid data returned from API")
+
+        # Extract each service's relevant details for the bin schedule
+        for key, value in rows_data.items():
+            if key.endswith("NextDate"):
+                BinType = key.replace("NextDate", "ServiceName")
+                for key2, value2 in rows_data.items():
+                    if key2 == BinType:
+                        BinType = value2
+                next_collection = datetime.strptime(
+                    remove_ordinal_indicator_from_date_string(value), "%A %d %B"
+                ).replace(year=datetime.now().year)
+                if datetime.now().month == 12 and next_collection.month == 1:
+                    next_collection = next_collection + relativedelta(years=1)
+
+                dict_data = {
+                    "type": BinType,
+                    "collectionDate": next_collection.strftime(date_format),
+                }
+                bindata["bins"].append(dict_data)
+
+        return bindata

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/HinckleyandBosworthBoroughCouncil.py

@@ -20,10 +20,16 @@ class CouncilClass(AbstractGetBinDataClass):
         check_uprn(user_uprn)
         bindata = {"bins": []}
 
+        headers = {
+            "Origin": "https://www.hinckley-bosworth.gov.uk",
+            "Referer": "https://www.hinckley-bosworth.gov.uk",
+            "User-Agent": "Mozilla/5.0",
+        }
+
         URI = f"https://www.hinckley-bosworth.gov.uk/set-location?id={user_uprn}&redirect=refuse&rememberloc="
 
         # Make the GET request
-        response = requests.get(URI)
+        response = requests.get(URI, headers=headers)
 
         # Parse the HTML
         soup = BeautifulSoup(response.content, "html.parser")

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/IpswichBoroughCouncil.py

@@ -31,7 +31,9 @@ class CouncilClass(AbstractGetBinDataClass):
     IBC_ENDPOINT = "https://app.ipswich.gov.uk/bin-collection/"
 
     def transform_date(self, date_str):
-        date_str = re.sub(r"(st|nd|rd|th)", "", date_str)  # Remove ordinal suffixes
+        date_str = re.sub(
+            r"(\d{1,2})(st|nd|rd|th)", r"\1", date_str
+        )  # Remove ordinal suffixes
         date_obj = datetime.strptime(date_str, "%A %d %B %Y")
         return date_obj.strftime(date_format)
 

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/LichfieldDistrictCouncil.py

@@ -24,10 +24,16 @@ class CouncilClass(AbstractGetBinDataClass):
         def solve(s):
             return re.sub(r"(\d)(st|nd|rd|th)", r"\1", s)
 
+        headers = {
+            "Origin": "https://www.lichfielddc.gov.uk",
+            "Referer": "https://www.lichfielddc.gov.uk",
+            "User-Agent": "Mozilla/5.0",
+        }
+
         URI = f"https://www.lichfielddc.gov.uk/homepage/6/bin-collection-dates?uprn={user_uprn}"
 
         # Make the GET request
-        response = requests.get(URI)
+        response = requests.get(URI, headers=headers)
 
         soup = BeautifulSoup(response.text, "html.parser")
 

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/NorthEastLincs.py

@@ -1,5 +1,7 @@
 import pandas as pd
+import requests
 from bs4 import BeautifulSoup
+
 from uk_bin_collection.uk_bin_collection.common import date_format
 from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
 
@@ -12,15 +14,26 @@ class CouncilClass(AbstractGetBinDataClass):
     """
 
     def parse_data(self, page: str, **kwargs) -> dict:
-        # Make a BS4 object
-        soup = BeautifulSoup(page.text, features="html.parser")
+        user_url = kwargs.get("url")
+
+        headers = {
+            "Origin": "https://www.nelincs.gov.uk",
+            "Referer": "https://www.nelincs.gov.uk",
+            "User-Agent": "Mozilla/5.0",
+        }
+
+        # Make the GET request
+        response = requests.get(user_url, headers=headers)
+
+        # Parse the HTML
+        soup = BeautifulSoup(response.content, "html.parser")
         soup.prettify()
 
         data = {"bins": []}
 
         # Get list items that can be seen on page
         for element in soup.find_all(
-            "li", {"class": "list-group-item p-0 p-3 bin-collection-item"}
+            "li", {"class": "border-0 list-group-item p-3 bg-light rounded p-2"}
         ):
             element_text = element.text.strip().split("\n\n")
             element_text = [x.strip() for x in element_text]
@@ -35,9 +48,7 @@ class CouncilClass(AbstractGetBinDataClass):
             data["bins"].append(dict_data)
 
         # Get hidden list items too
-        for element in soup.find_all(
-            "li", {"class": "list-group-item p-0 p-3 bin-collection-item d-none"}
-        ):
+        for element in soup.find_all("li", {"class": "border-0 list-group-item p-3"}):
             element_text = element.text.strip().split("\n\n")
             element_text = [x.strip() for x in element_text]
 

uk_bin_collection-0.153.0/uk_bin_collection/uk_bin_collection/councils/NorwichCityCouncil.py

@@ -0,0 +1,93 @@
+import requests
+from bs4 import BeautifulSoup
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+# import the wonderful Beautiful Soup and the URL grabber
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+
+        user_postcode = kwargs.get("postcode")
+        user_paon = kwargs.get("paon")
+        check_postcode(user_postcode)
+        check_paon(user_paon)
+        bindata = {"bins": []}
+
+        URI = "https://bnr-wrp.whitespacews.com/"
+
+        session = requests.Session()
+
+        # get link from first page as has some kind of unique hash
+        r = session.get(
+            URI,
+        )
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, features="html.parser")
+
+        alink = soup.find("a", text="View my collections")
+
+        if alink is None:
+            raise Exception("Initial page did not load correctly")
+
+        # greplace 'seq' query string to skip next step
+        nextpageurl = alink["href"].replace("seq=1", "seq=2")
+
+        data = {
+            "address_name_number": user_paon,
+            "address_postcode": user_postcode,
+        }
+
+        # get list of addresses
+        r = session.post(nextpageurl, data)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+
+        # get first address (if you don't enter enough argument values this won't find the right address)
+        alink = soup.find("div", id="property_list").find("a")
+
+        if alink is None:
+            raise Exception("Address not found")
+
+        nextpageurl = URI + alink["href"]
+
+        # get collection page
+        r = session.get(
+            nextpageurl,
+        )
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, features="html.parser")
+
+        if soup.find("span", id="waste-hint"):
+            raise Exception("No scheduled services at this address")
+
+        u1s = soup.find("section", id="scheduled-collections").find_all("u1")
+
+        for u1 in u1s:
+            lis = u1.find_all("li", recursive=False)
+
+            date = lis[1].text.replace("\n", "")
+            bin_type = lis[2].text.replace("\n", "")
+
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": datetime.strptime(
+                    date,
+                    "%d/%m/%Y",
+                ).strftime(date_format),
+            }
+            bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), date_format)
+        )
+
+        return bindata

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/NuneatonBedworthBoroughCouncil.py

@@ -1,23 +1,29 @@
+import re
+import urllib.parse
+
+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
 
-from bs4 import BeautifulSoup
-import urllib.parse
-import requests
-import re
-
 
 class CouncilClass(AbstractGetBinDataClass):
     def parse_data(self, page: str, **kwargs) -> dict:
 
         data = {"bins": []}
 
+        headers = {
+            "Origin": "https://www.nuneatonandbedworth.gov.uk/",
+            "Referer": "https://www.nuneatonandbedworth.gov.uk/",
+            "User-Agent": "Mozilla/5.0",
+        }
+
         street = urllib.parse.quote_plus(kwargs.get("paon"))
         base_url = "https://www.nuneatonandbedworth.gov.uk/"
         search_query = f"directory/search?directoryID=3&showInMap=&keywords={street}&search=Search+directory"
 
-        search_response = requests.get(base_url + search_query)
+        search_response = requests.get(base_url + search_query, headers=headers)
 
         if search_response.status_code == 200:
             soup = BeautifulSoup(search_response.content, "html.parser")
@@ -56,7 +62,13 @@ class CouncilClass(AbstractGetBinDataClass):
 
     def get_bin_data(self, url) -> dict:
 
-        bin_day_response = requests.get(url)
+        headers = {
+            "Origin": "https://www.nuneatonandbedworth.gov.uk/",
+            "Referer": "https://www.nuneatonandbedworth.gov.uk/",
+            "User-Agent": "Mozilla/5.0",
+        }
+
+        bin_day_response = requests.get(url, headers=headers)
 
         if bin_day_response.status_code == 200:
 

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/RunnymedeBoroughCouncil.py

@@ -21,10 +21,16 @@ class CouncilClass(AbstractGetBinDataClass):
         check_uprn(user_uprn)
         bindata = {"bins": []}
 
+        headers = {
+            "Origin": "https://www.runnymede.gov.uk",
+            "Referer": "https://www.runnymede.gov.uk",
+            "User-Agent": "Mozilla/5.0",
+        }
+
         URI = f"https://www.runnymede.gov.uk/homepage/150/check-your-bin-collection-day?address={user_uprn}"
 
         # Make the GET request
-        response = requests.get(URI)
+        response = requests.get(URI, headers=headers)
 
         soup = BeautifulSoup(response.text, "html.parser")
 

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/StaffordshireMoorlandsDistrictCouncil.py

@@ -77,6 +77,10 @@ class CouncilClass(AbstractGetBinDataClass):
         )
         submit.click()
 
+        WebDriverWait(driver, 10).until(
+            EC.presence_of_element_located((By.CLASS_NAME, "bin-collection__month"))
+        )
+
         soup = BeautifulSoup(driver.page_source, features="html.parser")
 
         # Quit Selenium webdriver to release session

{uk_bin_collection-0.152.11 → uk_bin_collection-0.153.0}/uk_bin_collection/uk_bin_collection/councils/WiltshireCouncil.py

@@ -1,3 +1,5 @@
+import re
+
 from bs4 import BeautifulSoup
 
 from uk_bin_collection.uk_bin_collection.common import *
@@ -91,40 +93,56 @@ class CouncilClass(AbstractGetBinDataClass):
 
             soup = BeautifulSoup(response.text, features="html.parser")
             soup.prettify()
-
+            # print(soup)
             # Find all the bits of the current calendar that contain an event
-            events = soup.find_all("div", {"class": "rc-event-container"})
+            resultscontainer = soup.find_all("div", {"class": "results-container"})
 
-            for event in events:
-                # Get the date and type of each bin collection
-                bin_date = datetime.strptime(
-                    event.find_next("a").attrs.get("data-original-datetext"),
-                    "%A %d %B, %Y",
+            for result in resultscontainer:
+                rows = result.find_all(
+                    "div", {"class": "col-12 col-sm-6 col-md-4 col-lg-4 mb-4"}
                 )
-                bin_type = event.find_next("a").attrs.get("data-original-title")
-                # Only process it if it's today or in the future
-                if bin_date.date() >= datetime.now().date():
-                    # Split the really long type up into two separate bins
-                    if (
-                        bin_type
-                        == "Mixed dry recycling (blue lidded bin) and glass (black box or basket)"
-                    ):
-                        collections.append(
-                            (
-                                "Mixed dry recycling (blue lidded bin)",
-                                datetime.strftime(bin_date, date_format),
+                for row in rows:
+                    cardcollectionday = row.find(
+                        "span", {"class": "card-collection-day"}
+                    )
+                    cardcollectiondate = row.find(
+                        "span", {"class": "card-collection-date"}
+                    )
+                    cardcollectionmonth = row.find(
+                        "span", {"class": "card-collection-month"}
+                    )
+                    bin_type = row.find(
+                        "li", {"class": re.compile(r"collection-type-...$")}
+                    ).text
+
+                    collection_date = f"{cardcollectionday.text}{cardcollectiondate.text}{cardcollectionmonth.text}"
+                    bin_date = datetime.strptime(
+                        collection_date,
+                        "%A %d %B %Y",
+                    )
+
+                    if bin_date.date() >= datetime.now().date():
+                        # Split the really long type up into two separate bins
+                        if (
+                            bin_type
+                            == "Mixed dry recycling (blue lidded bin) and glass (black box or basket)"
+                        ):
+                            collections.append(
+                                (
+                                    "Mixed dry recycling (blue lidded bin)",
+                                    datetime.strftime(bin_date, date_format),
+                                )
+                            )
+                            collections.append(
+                                (
+                                    "Glass (black box or basket)",
+                                    datetime.strftime(bin_date, date_format),
+                                )
                             )
-                        )
-                        collections.append(
-                            (
-                                "Glass (black box or basket)",
-                                datetime.strftime(bin_date, date_format),
+                        else:
+                            collections.append(
+                                (bin_type, datetime.strftime(bin_date, date_format))
                             )
-                        )
-                    else:
-                        collections.append(
-                            (bin_type, datetime.strftime(bin_date, date_format))
-                        )
 
         data = {"bins": []}