uk_bin_collection 0.74.0__py3-none-any.whl

uk_bin_collection/uk_bin_collection/councils/RenfrewshireCouncil.py

@@ -0,0 +1,135 @@
+from bs4 import BeautifulSoup
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+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):
+    """
+    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:
+        driver = None
+        try:
+            data = {"bins": []}
+            user_paon = kwargs.get("paon")
+            user_postcode = kwargs.get("postcode")
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+            check_paon(user_paon)
+            check_postcode(user_postcode)
+
+            # Create Selenium webdriver
+            driver = create_webdriver(web_driver, headless)
+            driver.get(
+                "https://www.renfrewshire.gov.uk/article/2320/Check-your-bin-collection-day"
+            )
+
+            accept_button = WebDriverWait(driver, timeout=30).until(
+                EC.element_to_be_clickable((By.ID, "ccc-notify-accept"))
+            )
+            accept_button.click()
+
+            # Wait for the postcode field to appear then populate it
+            inputElement_postcode = WebDriverWait(driver, 30).until(
+                EC.presence_of_element_located(
+                    (By.ID, "RENFREWSHIREBINCOLLECTIONS_PAGE1_ADDRESSLOOKUPPOSTCODE")
+                )
+            )
+            inputElement_postcode.send_keys(user_postcode)
+
+            # Click search button
+            findAddress = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (By.ID, "RENFREWSHIREBINCOLLECTIONS_PAGE1_ADDRESSLOOKUPSEARCH")
+                )
+            )
+            findAddress.click()
+
+            # Wait for the 'Select address' dropdown to appear and select option matching the house name/number
+            WebDriverWait(driver, 10).until(
+                EC.element_to_be_clickable(
+                    (
+                        By.XPATH,
+                        "//select[@id='RENFREWSHIREBINCOLLECTIONS_PAGE1_ADDRESSLOOKUPADDRESS']//option[contains(., '"
+                        + user_paon
+                        + "')]",
+                    )
+                )
+            ).click()
+
+            # Wait for the collections table to appear
+            WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (By.ID, "RENFREWSHIREBINCOLLECTIONS_PAGE1_COLLECTIONDETAILS")
+                )
+            )
+
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+
+            next_collection_div = soup.find(
+                "div", {"class": "collection collection--next"}
+            )
+
+            next_collection_date = datetime.strptime(
+                next_collection_div.find("p", {"class": "collection__date"})
+                .get_text()
+                .strip(),
+                "%A %d %B %Y",
+            )
+
+            next_collection_bin = next_collection_div.findAll(
+                "p", {"class": "bins__name"}
+            )
+
+            for row in next_collection_bin:
+                dict_data = {
+                    "type": row.get_text().strip(),
+                    "collectionDate": next_collection_date.strftime("%d/%m/%Y"),
+                }
+                data["bins"].append(dict_data)
+
+            future_collection_div = soup.find(
+                "div", {"class": "collection collection--future"}
+            )
+
+            future_collection_row = future_collection_div.findAll(
+                "div", {"class": "collection__row"}
+            )
+
+            for collection_row in future_collection_row:
+                future_collection_date = datetime.strptime(
+                    collection_row.find("p", {"class": "collection__date"})
+                    .get_text()
+                    .strip(),
+                    "%A %d %B %Y",
+                )
+                future_collection_bin = collection_row.findAll(
+                    "p", {"class": "bins__name"}
+                )
+
+                for row in future_collection_bin:
+                    dict_data = {
+                        "type": row.get_text().strip(),
+                        "collectionDate": future_collection_date.strftime("%d/%m/%Y"),
+                    }
+
+                    data["bins"].append(dict_data)
+
+        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
+        finally:
+            # This block ensures that the driver is closed regardless of an exception
+            if driver:
+                driver.quit()
+        return data

uk_bin_collection/uk_bin_collection/councils/RhonddaCynonTaffCouncil.py

@@ -0,0 +1,80 @@
+from bs4 import BeautifulSoup
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    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": []}
+
+        # Get UPRN from kwargs
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+
+        # Construct headers and set passed UPRN as a param for request
+        headers = {
+            "authority": "www.rctcbc.gov.uk",
+            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "accept-language": "en-GB,en;q=0.9",
+            "cache-control": "no-cache",
+            # 'cookie': 'ASP.NET_SessionId=2b4gaaydt1rlu5pccgrpzamm',
+            "pragma": "no-cache",
+            "referer": "https://www.rctcbc.gov.uk/EN/Resident/RecyclingandWaste/RecyclingandWasteCollectionDays.aspx?PropertyNumber=&Postcode=CF72%209JD",
+            "sec-ch-ua": '"Chromium";v="116", "Not)A;Brand";v="24", "Opera GX";v="102"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "document",
+            "sec-fetch-mode": "navigate",
+            "sec-fetch-site": "same-origin",
+            "sec-fetch-user": "?1",
+            "upgrade-insecure-requests": "1",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.5845.188 Safari/537.36",
+        }
+        params = {
+            "uprn": user_uprn,
+        }
+
+        response = requests.get(
+            "https://www.rctcbc.gov.uk/EN/Resident/RecyclingandWaste/RecyclingandWasteCollectionDays.aspx",
+            params=params,
+            headers=headers,
+        )
+
+        # Throw an error if response is not HTTP200
+        if response.status_code != 200:
+            raise SystemError(
+                "Response status was not 200: Please raise an issue on GitHub!"
+            )
+
+        # Parse response page and get all table rows
+        soup = BeautifulSoup(response.text, features="html.parser")
+        soup.prettify()
+        table_rows = soup.find("table", class_=("waste-table")).find_all("tr")
+
+        # Find the bin type and parse the date for each row, then add to dict. First row will be just headings,
+        # so skip it
+        for row in table_rows:
+            if len(row.contents) > 3:
+                continue
+            bin_type = row.contents[1].text.strip()
+            bin_date_text = (
+                row.contents[2].text.split(",")[1].strip().replace(" of ", "")
+            )
+            bin_date = datetime.strptime(
+                remove_ordinal_indicator_from_date_string(bin_date_text), "%A %d %B %Y"
+            ).strftime(date_format)
+
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": bin_date,
+            }
+            data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/RochdaleCouncil.py

@@ -0,0 +1,69 @@
+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:
+        api_url = "https://webforms.rochdale.gov.uk/BinCalendar"
+        user_postcode = kwargs.get("postcode")
+        user_uprn = kwargs.get("uprn")
+
+        # Check the postcode and UPRN are valid
+        check_postcode(user_postcode)
+        check_uprn(user_uprn)
+
+        # Create the form data
+        form_data = {
+            "PostCode": user_postcode,
+            "SelectedUprn": user_uprn,
+            "Step": 2,
+        }
+
+        # Make a request to the API
+        requests.packages.urllib3.disable_warnings()
+        response = requests.post(api_url, data=form_data)
+
+        # Make a BS4 object
+        soup = BeautifulSoup(response.text, features="html.parser")
+        soup.prettify()
+
+        data = {"bins": []}
+
+        # Get the table element and rows
+        table_element = soup.find("table", {"id": "tblCollectionDetails"})
+        table_rows = table_element.find_all_next("tr")
+
+        row_index = 0
+        for row in table_rows:
+            if row_index < 1:
+                row_index += 1
+                continue
+            else:
+                # Get the date from the th element
+                date = datetime.strptime(
+                    row.find("th").get_text().strip(), "%A %d %B %Y"
+                ).strftime(date_format)
+
+                # Get the bin types from the td elements and filter out the empty ones
+                bin_types = filter(lambda td: td.find("img"), row.find_all("td"))
+
+                # Convert the bin types to a list
+                bin_types_list = list(bin_types)
+
+                # Append the bin type and date to the data dict
+                for td in bin_types_list:
+                    img = td.find("img")
+                    bin_type_text = img["alt"]
+                    data["bins"].append({"type": bin_type_text, "collectionDate": date})
+
+                row_index += 1
+
+        return data

uk_bin_collection/uk_bin_collection/councils/RochfordCouncil.py

@@ -0,0 +1,60 @@
+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 dateutil.relativedelta import relativedelta
+from datetime import timedelta
+
+
+# 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": []}
+
+        # response = requests.get('https://www.rochford.gov.uk/online-bin-collections-calendar', headers=headers)
+        soup = BeautifulSoup(page.text, features="html.parser")
+        soup.prettify()
+        year = soup.find_all("table", {"class": "responsive-enabled govuk-table"})
+
+        current_month = datetime.now().strftime("%B %Y")
+        next_month = (datetime.now() + relativedelta(months=1, day=1)).strftime("%B %Y")
+
+        for month in year:
+            heading = (
+                month.find("th", {"class": "govuk-table__header"}).get_text().strip()
+            )
+            if heading == current_month or heading == next_month:
+                for week in month.find("tbody").find_all(
+                    "tr", {"class": "govuk-table__row"}
+                ):
+                    week_text = week.get_text().strip().split("\n")
+                    collection_date = datetime.strptime(
+                        remove_ordinal_indicator_from_date_string(
+                            week_text[0].split(" - ")[0]
+                        ),
+                        "%A %d %B",
+                    )
+                    next_collection = collection_date.replace(year=datetime.now().year)
+                    if datetime.now().month == 12 and next_collection.month == 1:
+                        next_collection = next_collection + relativedelta(years=1)
+                    bin_type = (
+                        week_text[1]
+                        .replace("collection week", "bin")
+                        .strip()
+                        .capitalize()
+                    )
+                    if next_collection.date() >= (datetime.now().date() - timedelta(6)):
+                        dict_data = {
+                            "type": bin_type,
+                            "collectionDate": next_collection.strftime(date_format),
+                        }
+                        data["bins"].append(dict_data)
+            else:
+                continue
+
+        return data

uk_bin_collection/uk_bin_collection/councils/RugbyBoroughCouncil.py

@@ -0,0 +1,93 @@
+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": []}
+        bin_types = {
+            "240L RUBBISH BIN": "Black bin",
+            "240L GARDEN BIN": "Green bin",
+            "180L RECYCLING BIN": "Blue lid bin",
+        }
+        collections = []
+
+        user_postcode = kwargs.get("postcode")
+        user_uprn = kwargs.get("uprn")
+
+        check_uprn(user_uprn)
+        check_postcode(user_postcode)
+
+        headers = {
+            "authority": "www.rugby.gov.uk",
+            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "accept-language": "en-GB,en;q=0.9",
+            "cache-control": "no-cache",
+            "content-type": "application/x-www-form-urlencoded",
+            # 'cookie': 'JSESSIONID=7E90CAB54B649C3DCC7F6B5DA0897C63; COOKIE_SUPPORT=true; GUEST_LANGUAGE_ID=en_GB; AWSELB=D941E98916B5759862ED6C39DA9FB3FD9880491851D200C98112ABEC3223D52B19A2A2C6B37A89D3650D44FA5728FCAFEDE7BB2592D948FFF9C7B18D76C41AF02C308B0F3A2DE17F1585E9959BCE68CC83BC3AC753; CookieControl={"necessaryCookies":[],"optionalCookies":{},"statement":{},"consentDate":1701710876715,"consentExpiry":90,"interactedWith":true,"user":"8FED8810-3C3E-4D50-A9DC-42655030B3B1"}',
+            "origin": "https://www.rugby.gov.uk",
+            "pragma": "no-cache",
+            "referer": "https://www.rugby.gov.uk/check-your-next-bin-day",
+            "sec-ch-ua": '"Chromium";v="118", "Opera GX";v="104", "Not=A?Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "document",
+            "sec-fetch-mode": "navigate",
+            "sec-fetch-site": "same-origin",
+            "sec-fetch-user": "?1",
+            "upgrade-insecure-requests": "1",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.5993.118 Safari/537.36",
+        }
+        params = {
+            "p_p_id": "com_placecube_digitalplace_local_waste_portlet_CollectionDayFinderPortlet",
+            "p_p_lifecycle": "0",
+            "p_p_state": "normal",
+            "p_p_mode": "view",
+            "_com_placecube_digitalplace_local_waste_portlet_CollectionDayFinderPortlet_mvcRenderCommandName": "/collection_day_finder/get_days",
+        }
+        data = {
+            "_com_placecube_digitalplace_local_waste_portlet_CollectionDayFinderPortlet_formDate": f"{datetime.now().timestamp().__floor__()}",
+            "_com_placecube_digitalplace_local_waste_portlet_CollectionDayFinderPortlet_postcode": f"{user_postcode}",
+            "_com_placecube_digitalplace_local_waste_portlet_CollectionDayFinderPortlet_uprn": f"{user_uprn}",
+        }
+
+        response = requests.post(
+            "https://www.rugby.gov.uk/check-your-next-bin-day",
+            params=params,
+            headers=headers,
+            data=data,
+        )
+
+        soup = BeautifulSoup(response.text, features="html.parser")
+        soup.prettify()
+
+        table_rows = soup.find("table", {"class": "table"}).find("tbody").find_all("tr")
+
+        for row in table_rows:
+            row_text = row.text.strip().split("\n")
+            bin_type = bin_types.get(row_text[0])
+            collections.append(
+                (bin_type, datetime.strptime(row_text[1], "%A %d %b %Y"))
+            )
+            collections.append(
+                (bin_type, datetime.strptime(row_text[3], "%A %d %b %Y"))
+            )
+
+        ordered_data = sorted(collections, key=lambda x: x[1])
+        data = {"bins": []}
+        for item in ordered_data:
+            dict_data = {
+                "type": item[0],
+                "collectionDate": item[1].strftime(date_format),
+            }
+            data["bins"].append(dict_data)
+
+        return data

uk_bin_collection/uk_bin_collection/councils/RushcliffeBoroughCouncil.py

@@ -0,0 +1,100 @@
+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
+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):
+    """
+    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:
+        driver = None
+        try:
+            page = "https://selfservice.rushcliffe.gov.uk/renderform.aspx?t=1242&k=86BDCD8DE8D868B9E23D10842A7A4FE0F1023CCA"
+
+            data = {"bins": []}
+
+            user_uprn = kwargs.get("uprn")
+            user_postcode = kwargs.get("postcode")
+            web_driver = kwargs.get("web_driver")
+            headless = kwargs.get("headless")
+            check_uprn(user_uprn)
+            check_postcode(user_postcode)
+
+            # Create Selenium webdriver
+            driver = create_webdriver(web_driver, headless)
+            driver.get(page)
+
+            # Populate postcode field
+            inputElement_postcode = driver.find_element(
+                By.ID,
+                "ctl00_ContentPlaceHolder1_FF3518TB",
+            )
+            inputElement_postcode.send_keys(user_postcode)
+
+            # Click search button
+            driver.find_element(
+                By.ID,
+                "ctl00_ContentPlaceHolder1_FF3518BTN",
+            ).click()
+
+            # Wait for the 'Select address' dropdown to appear and select option matching UPRN
+            dropdown = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (By.ID, "ctl00_ContentPlaceHolder1_FF3518DDL")
+                )
+            )
+            # Create a 'Select' for it, then select the matching URPN option
+            dropdownSelect = Select(dropdown)
+            dropdownSelect.select_by_value("U" + user_uprn)
+
+            # Wait for the submit button to appear, then click it to get the collection dates
+            submit = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located(
+                    (By.ID, "ctl00_ContentPlaceHolder1_btnSubmit")
+                )
+            )
+            submit.click()
+
+            soup = BeautifulSoup(driver.page_source, features="html.parser")
+
+            bins_text = soup.find("div", id="ctl00_ContentPlaceHolder1_pnlConfirmation")
+
+            if bins_text:
+                results = re.findall(
+                    "Your (.*?) bin will next be collected on (\d\d?\/\d\d?\/\d{4})",
+                    bins_text.find("div", {"class": "ss_confPanel"}).get_text(),
+                )
+                if results:
+                    for result in results:
+                        collection_date = datetime.strptime(result[1], "%d/%m/%Y")
+                        dict_data = {
+                            "type": result[0],
+                            "collectionDate": collection_date.strftime(date_format),
+                        }
+                        data["bins"].append(dict_data)
+
+                        data["bins"].sort(
+                            key=lambda x: datetime.strptime(
+                                x.get("collectionDate"), "%d/%m/%Y"
+                            )
+                        )
+        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
+        finally:
+            # This block ensures that the driver is closed regardless of an exception
+            if driver:
+                driver.quit()
+        return data

uk_bin_collection/uk_bin_collection/councils/RushmoorCouncil.py

@@ -0,0 +1,81 @@
+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 lxml import etree
+
+
+# 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
+        soup = BeautifulSoup(page.text, features="lxml")
+        soup.prettify()
+        data = {"bins": []}
+        collections = []
+
+        # Convert the XML to JSON and load the next collection data
+        result = soup.find("p").contents[0].text.replace("\\", "")[1:-1]
+        json_data = json.loads(result)["NextCollection"]
+
+        # Get general waste data
+        if json_data.get("RefuseCollectionBinDate") is not None:
+            bin_type = "Green general waste bin"
+            if json_data.get("RefuseBinExceptionMessage") != "":
+                bin_type += f" ({json_data.get('RefuseBinExceptionMessage')})".rstrip()
+            bin_date = datetime.strptime(
+                json_data.get("RefuseCollectionBinDate"), "%Y-%m-%dT%H:%M:%S"
+            )
+            collections.append((bin_type, bin_date))
+
+        # Get recycling waste data
+        if json_data.get("RecyclingCollectionDate") is not None:
+            bin_type = "Blue recycling bin"
+            if json_data.get("RecyclingExceptionMessage") != "":
+                bin_type += f" ({json_data.get('RecyclingExceptionMessage')})".rstrip()
+            bin_date = datetime.strptime(
+                json_data.get("RecyclingCollectionDate"), "%Y-%m-%dT%H:%M:%S"
+            )
+            collections.append((bin_type, bin_date))
+
+        # Get garden waste data
+        if json_data.get("GardenWasteCollectionDate") is not None:
+            bin_type = "Brown garden waste bin"
+            if json_data.get("GardenWasteExceptionMessage") != "":
+                bin_type += (
+                    f" ({json_data.get('GardenWasteExceptionMessage')})".rstrip()
+                )
+            bin_date = datetime.strptime(
+                json_data.get("GardenWasteCollectionDate"), "%Y-%m-%dT%H:%M:%S"
+            )
+            collections.append((bin_type, bin_date))
+
+        # Get food waste data
+        if json_data.get("FoodWasteCollectionDate") is not None:
+            bin_type = "Black food waste bin"
+            if json_data.get("FoodWasteExceptionMessage") != "":
+                bin_type += f" ({json_data.get('FoodWasteExceptionMessage')})".rstrip()
+            bin_date = datetime.strptime(
+                json_data.get("FoodWasteCollectionDate"), "%Y-%m-%dT%H:%M:%S"
+            )
+            collections.append((bin_type, bin_date))
+
+        # If there's no collections, raise an error
+        if len(collections) < 1:
+            raise ValueError("No collections found")
+
+        # Order the collection by date, then return them
+        ordered_data = sorted(collections, key=lambda x: x[1])
+        for bin in ordered_data:
+            dict_data = {
+                "type": bin[0],
+                "collectionDate": bin[1].strftime(date_format),
+            }
+            data["bins"].append(dict_data)
+
+        return data