@camstack/addon-waste-collections 0.0.0-stage → 0.1.1

package/python/vendor/waste_collection_schedule/source/boston_gov_uk.py

@@ -0,0 +1,216 @@
+import base64
+import json
+import re
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Boston Borough Council"
+DESCRIPTION = "Source for www.boston.gov.uk services for Boston Borough Council, UK."
+URL = "https://www.boston.gov.uk"
+COUNTRY = "uk"
+TEST_CASES = {
+    "43 Tarry Hill, Swineshead, PE20 3LW": {
+        "postcode": "PE20 3LW",
+        "property": "43",
+    },
+    "The Old Vicarage, Church Close, PE21 6NE": {
+        "postcode": "PE21 6NE",
+        "property": "10",
+    },
+}
+
+ICON_MAP = {
+    "refusebin": Icons.GENERAL_WASTE,
+    "papercardbin": Icons.PAPER,
+    "recyclingbin": Icons.RECYCLING,
+    "greenbin": Icons.ORGANIC,
+    "foodbin": Icons.BIO_KITCHEN,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "postcode": "Postcode",
+        "property": "Property name or number",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "postcode": "Your property postcode, e.g. PE20 3LW",
+        "property": "Your property name or number, e.g. 43",
+    }
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your postcode and property name or number as they appear on the Boston Borough Council website: https://www.boston.gov.uk/article/27449/Your-Waste-Collections"
+}
+
+FORM_URL = "https://www.boston.gov.uk/article/27449/Your-Waste-Collections"
+FORM_NAME = "BBCWASTECOLLECTIONSV2"
+
+
+def _decode_sv(text: str) -> dict:
+    """Decode the serialized variables from the GOSS form page."""
+    match = re.search(rf"var {FORM_NAME}SerializedVariables = \"([^\"]+)\"", text)
+    if not match:
+        return {}
+    return json.loads(base64.b64decode(match.group(1)))
+
+
+def _get_form_params(text: str) -> dict:
+    """Extract the GOSS form session parameters from a page."""
+    nonce = re.search(rf'"{FORM_NAME}_NONCE" value="([\w-]+)"', text)
+    sessionid = re.search(rf'"{FORM_NAME}_SESSIONID" value="([\w-]+)"', text)
+    pagesessionid = re.search(rf'"{FORM_NAME}_PAGESESSIONID" value="([\w-]+)"', text)
+    return {
+        "nonce": nonce.group(1) if nonce else "",
+        "sessionid": sessionid.group(1) if sessionid else "",
+        "pagesessionid": pagesessionid.group(1) if pagesessionid else "",
+    }
+
+
+def _get_url_params(url: str) -> dict:
+    """Extract pageSessionId and fsn from a URL."""
+    psi = re.search(r"pageSessionId=([\w-]+)", url)
+    fsn = re.search(r"fsn=([\w-]+)", url)
+    return {
+        "pagesessionid_url": psi.group(1) if psi else "",
+        "fsn_url": fsn.group(1) if fsn else "",
+    }
+
+
+class Source:
+    def __init__(self, postcode: str, property: str = ""):
+        self._postcode = postcode
+        self._property = property
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update(
+            {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            }
+        )
+
+        # Step 1: Load initial form page to get session tokens
+        r1 = session.get(FORM_URL, timeout=30)
+        r1.raise_for_status()
+
+        url_params1 = _get_url_params(r1.url)
+        form_params1 = _get_form_params(r1.text)
+        psi1 = re.search(r"pageSessionId=([\w-]+)", r1.text)
+
+        submission_url1 = (
+            f"https://www.boston.gov.uk/apiserver/formsservice/http/processsubmission"
+            f"?pageSessionId={psi1.group(1) if psi1 else url_params1['pagesessionid_url']}"
+            f"&fsid={form_params1['sessionid']}"
+            f"&fsn={form_params1['nonce']}"
+        )
+
+        # Step 2: Submit search form with postcode and property number
+        data2 = {
+            f"{FORM_NAME}_PAGESESSIONID": form_params1["pagesessionid"],
+            f"{FORM_NAME}_SESSIONID": form_params1["sessionid"],
+            f"{FORM_NAME}_NONCE": form_params1["nonce"],
+            f"{FORM_NAME}_VARIABLES": "",
+            f"{FORM_NAME}_PAGENAME": "COLLECTIONS",
+            f"{FORM_NAME}_PAGEINSTANCE": "0",
+            f"{FORM_NAME}_COLLECTIONS_SEARCHPROPERTYNAMENUMBER": self._property,
+            f"{FORM_NAME}_COLLECTIONS_SEARCHPOSTCODE": self._postcode,
+            f"{FORM_NAME}_FORMACTION_NEXT": f"{FORM_NAME}_COLLECTIONS_START10",
+        }
+
+        r2 = session.post(
+            submission_url1,
+            data=data2,
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            allow_redirects=True,
+            timeout=30,
+        )
+        r2.raise_for_status()
+
+        sv2 = _decode_sv(r2.text)
+        addr_options = sv2.get("ADDRESSUPRN_OPTIONDATA", {}).get("value", [])
+
+        # Filter out placeholder entries (empty UPRN / "Select address")
+        valid_options = [
+            a
+            for a in addr_options
+            if a[0] and str(a[0]).strip() and a[1] != "Select address"
+        ]
+
+        if not valid_options:
+            raise ValueError(
+                f"No addresses found for postcode '{self._postcode}' "
+                f"and property '{self._property}'. "
+                "Please check your postcode and property name/number."
+            )
+
+        # Use first matching address
+        uprn = valid_options[0][0]
+
+        url_params2 = _get_url_params(r2.url)
+        form_params2 = _get_form_params(r2.text)
+
+        submission_url2 = (
+            f"https://www.boston.gov.uk/apiserver/formsservice/http/processsubmission"
+            f"?pageSessionId={url_params2['pagesessionid_url']}"
+            f"&fsid={form_params2['sessionid']}"
+            f"&fsn={url_params2['fsn_url']}"
+        )
+
+        # Step 3: Select address by UPRN to get collection data
+        data3 = {
+            f"{FORM_NAME}_PAGESESSIONID": form_params2["pagesessionid"],
+            f"{FORM_NAME}_SESSIONID": form_params2["sessionid"],
+            f"{FORM_NAME}_NONCE": form_params2["nonce"],
+            f"{FORM_NAME}_VARIABLES": "",
+            f"{FORM_NAME}_PAGENAME": "ADDRESS",
+            f"{FORM_NAME}_PAGEINSTANCE": "0",
+            f"{FORM_NAME}_ADDRESS_FIELD1034": "false",
+            f"{FORM_NAME}_ADDRESS_FIELD1036": "false",
+            f"{FORM_NAME}_ADDRESS_FIELD1041": "true",
+            f"{FORM_NAME}_ADDRESS_FIELD1042": "false",
+            f"{FORM_NAME}_ADDRESS_ADDRESSUPRN": str(uprn),
+            f"{FORM_NAME}_FORMACTION_NEXT": f"{FORM_NAME}_ADDRESS_NEXT3",
+        }
+
+        r3 = session.post(
+            submission_url2,
+            data=data3,
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            allow_redirects=True,
+            timeout=30,
+        )
+        r3.raise_for_status()
+
+        sv3 = _decode_sv(r3.text)
+        collections_data = sv3.get("collectionsData", {}).get("value", {})
+
+        if not collections_data.get("success"):
+            raise ValueError(
+                f"Failed to retrieve collection data for UPRN {uprn}. "
+                "The council website may be temporarily unavailable."
+            )
+
+        jobs = collections_data.get("jobs", [])
+        entries = []
+        for job in jobs:
+            next_date_str = job.get("NextDate")
+            if not next_date_str:
+                continue
+            try:
+                next_date = datetime.strptime(next_date_str, "%Y-%m-%d").date()
+            except ValueError:
+                continue
+
+            bin_type = job.get("Type", "").lower()
+            title = job.get("Title", bin_type)
+            icon = ICON_MAP.get(bin_type)
+
+            entries.append(Collection(date=next_date, t=title, icon=icon))
+
+        return entries

package/python/vendor/waste_collection_schedule/source/bracknell_forest_gov_uk.py

@@ -0,0 +1,97 @@
+import json
+
+import requests
+from dateutil import parser
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Bracknell Forest Council"
+DESCRIPTION = "Bracknell Forest Council, UK - Waste Collection"
+URL = "https://selfservice.mybfc.bracknell-forest.gov.uk"
+TEST_CASES = {
+    "44 Kennel Lane": {"house_number": "44", "post_code": "RG42 2HB"},
+    "28 Kennel Lane": {"house_number": "28", "post_code": "RG42 2HB"},
+    "32 Ashbourne": {"house_number": "32", "post_code": "RG12 8SG"},
+    "1 Acacia Avenue": {"house_number": "1", "post_code": "GU47 0RU"},
+    "Myrtle, 39 New Wokingham Road": {
+        "house_number": "Myrtle",
+        "post_code": "RG45 6JG",
+    },
+}
+
+ICON_MAP = {
+    "general waste": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+    "garden": Icons.GARDEN,
+    "food": Icons.BIO_KITCHEN,
+}
+
+
+class Source:
+    def __init__(self, post_code: str, house_number: str):
+        self.params = {
+            "webpage_subpage_id": "PAG0000570FEFFB1",
+            "webpage_token": "390170046582b0e3d7ca68ef1d6b4829ccff0b1ae9c531047219c6f9b5295738",
+            "widget_action": "handle_event",
+        }
+        self.headers = {
+            "Accept": "application/json",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+        self.data = {
+            "action_cell_id": "PCL0003988FEFFB1",
+            "action_page_id": "PAG0000570FEFFB1",
+        }
+        self.url = f"{URL}/w/webpage/waste-collection-days"
+        self.post_code = post_code
+        self.house_number = str(house_number)
+
+        if self.house_number.isnumeric():
+            self.house_number = f"{self.house_number} "
+
+    def fetch(self):
+        address_lookup = requests.post(
+            self.url,
+            params=self.params,
+            headers=self.headers,
+            data={
+                "code_action": "find_addresses",
+                "code_params": json.dumps({"search": self.post_code}),
+            }
+            | self.data,
+        )
+        address_lookup.raise_for_status()
+        addresses = address_lookup.json()["response"]["addresses"]["items"]
+        id = next(
+            address
+            for address in addresses
+            if address["Description"].upper().startswith(self.house_number.upper())
+        )["Id"]
+
+        collection_lookup = requests.post(
+            self.url,
+            params=self.params,
+            headers=self.headers,
+            data={
+                "code_action": "find_rounds",
+                "code_params": json.dumps({"addressId": id}),
+            }
+            | self.data,
+        )
+        collection_lookup.raise_for_status()
+        collections = collection_lookup.json()["response"]["collections"]
+        entries = []
+        for collection_entry in collections:
+            try:
+                coll_day = parser.parse(collection_entry["firstDate"]["date"]).date()
+            except (KeyError, TypeError):
+                # KeyError for missing keys, TypeError for null/None firstDate
+                continue
+            entries.append(
+                Collection(
+                    date=coll_day,
+                    t=collection_entry["round"],
+                    icon=ICON_MAP.get(collection_entry["round"].lower()),
+                )
+            )
+
+        return entries

package/python/vendor/waste_collection_schedule/source/bradford_gov_uk.py

@@ -0,0 +1,95 @@
+import ssl
+from datetime import datetime
+
+import requests
+import urllib3
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Bradford Metropolitan District Council"
+DESCRIPTION = (
+    "Source for Bradford.gov.uk services for Bradford Metropolitan Council, UK."
+)
+URL = "https://bradford.gov.uk"
+TEST_CASES = {
+    "Ilkley": {"uprn": "100051250665"},
+    "Bradford": {"uprn": "100051239296"},
+    "Baildon": {"uprn": 10002329242},
+}
+
+API_URL = "https://onlineforms.bradford.gov.uk/ufs/"
+ICON_MAP = {
+    "REFUSE": Icons.GENERAL_WASTE,
+    "RECYCLING": Icons.RECYCLING,
+    "GARDEN": Icons.GARDEN,
+}
+
+
+class CustomHttpAdapter(requests.adapters.HTTPAdapter):
+    """Transport adapter" that allows us to use custom ssl_context."""
+
+    def __init__(self, ssl_context=None, **kwargs):
+        self.ssl_context = ssl_context
+        super().__init__(**kwargs)
+
+    def init_poolmanager(self, connections, maxsize, block=False):
+        self.poolmanager = urllib3.poolmanager.PoolManager(
+            num_pools=connections,
+            maxsize=maxsize,
+            block=block,
+            ssl_context=self.ssl_context,
+        )
+
+
+class Source:
+    def __init__(self, uprn: str):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        entries = []
+
+        s = requests.Session()
+        # In openssl3 some context is needed to access this host
+        # or an UNSAFE_LEGACY_RENEGOTIATION_DISABLED error will occur
+        ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        ctx.options |= 0x4
+        s.mount("https://", CustomHttpAdapter(ctx))
+
+        s.cookies.set(
+            "COLLECTIONDATES", self._uprn, domain="onlineforms.bradford.gov.uk"
+        )
+        r = s.get(f"{API_URL}/collectiondates.eb")
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+        div = soup.find_all("table", {"role": "region"})
+        for region in div:
+            displayClass = list(
+                filter(lambda x: x.endswith("-Override-Panel"), region["class"])
+            )
+            if len(displayClass) > 0:
+                heading = region.find_all(
+                    "td", {"class": displayClass[0].replace("Panel", "Header")}
+                )
+                type = "UNKNOWN"
+                if "General" in heading[0].text:
+                    type = "REFUSE"
+                elif "Recycling" in heading[0].text:
+                    type = "RECYCLING"
+                elif "Garden" in heading[0].text:
+                    type = "GARDEN"
+                lines = region.find_all("div", {"type": "text"})
+                for entry in lines:
+                    try:
+                        entries.append(
+                            Collection(
+                                date=datetime.strptime(
+                                    entry.text.strip(), "%a %b %d %Y"
+                                ).date(),
+                                t=type,
+                                icon=ICON_MAP.get(type),
+                            )
+                        )
+                    except ValueError:
+                        pass  # ignore date conversion failure for not scheduled collections
+
+        return entries

package/python/vendor/waste_collection_schedule/source/braintree_gov_uk.py

@@ -0,0 +1,89 @@
+import requests
+from bs4 import BeautifulSoup
+from dateutil import parser
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Braintree District Council"
+DESCRIPTION = "Braintree District Council, UK - Waste Collection"
+URL = "https://www.braintree.gov.uk"
+TEST_CASES = {
+    "30 Boars Tye Road": {"house_number": 30, "post_code": "CM8 3QE"},
+    "64 Silver Street": {"house_number": "64", "post_code": "CM8 3QG"},
+    "18 St Mary's Road": {"house_number": "1", "post_code": "CM8 3PE"},
+    "20 Peel Crescent": {"house_number": "20", "post_code": "CM7 2RS"},
+    "Causeway House": {"house_number": "Causeway House", "post_code": "CM7 9HB"},
+}
+NAME_MAP = {
+    "Non-recyclable waste(grey bin)": "Grey Bin",
+    "Outdoorfood caddy": "Food Bin",
+    "Outdoor food caddy": "Food Bin",
+    "Mixed recycling(blue-lidded bin)": "Mixed Recycling",
+    "Paper and card recycling(red-lidded bin)": "Paper & Card",
+    "Garden bin(green bin)": "Garden Bin",
+}
+ICON_MAP = {
+    "Grey Bin": Icons.GENERAL_WASTE,
+    "Mixed Recycling": Icons.RECYCLING,
+    "Paper & Card": Icons.PAPER,
+    "Garden Bin": Icons.GARDEN,
+    "Food Bin": Icons.BIO_KITCHEN,
+}
+
+
+class Source:
+    def __init__(self, post_code: str, house_number: str):
+        self.post_code = post_code
+        self.house_number = str(house_number)
+        self.url = f"{URL}/xfp/form/554"
+
+    def initialize_form_data(self):
+        self.form_data = {
+            "qe15dda0155d237d1ea161004d1839e3369ed4831_0_0": (None, self.post_code),
+            "page": (None, 5730),
+        }
+
+    def fetch(self):
+        self.initialize_form_data()  # Re-initialize form data before each fetch otherwise subsequent fetches fail
+        address_lookup = requests.post(self.url, files=self.form_data)
+        address_lookup.raise_for_status()
+        addresses = {}
+        for address in BeautifulSoup(address_lookup.text, "html.parser").find_all(
+            "option"
+        ):
+            if len(address["value"]) > 5:  # Skip the first option
+                addresses[address["value"]] = address.text.strip()
+        id = next(
+            address
+            for address in addresses
+            if addresses[address].startswith(self.house_number)
+        )
+        self.form_data["qe15dda0155d237d1ea161004d1839e3369ed4831_1_0"] = (None, id)
+        self.form_data["next"] = (None, "Next")
+        collection_lookup = requests.post(self.url, files=self.form_data)
+        collection_lookup.raise_for_status()
+        entries = []
+        for results in BeautifulSoup(collection_lookup.text, "html.parser").find_all(
+            "div", class_="date_display"
+        ):
+            try:
+                collection_info = results.text.strip().split("\n")
+                collection_type = NAME_MAP.get(
+                    collection_info[0].strip(), collection_info[0].strip()
+                )
+
+                # Skip if no collection date is found
+                if len(collection_info) < 2:
+                    continue
+
+                collection_date = collection_info[1].strip()
+
+                entries.append(
+                    Collection(
+                        date=parser.parse(collection_date, dayfirst=True).date(),
+                        t=collection_type,
+                        icon=ICON_MAP.get(collection_type),
+                    )
+                )
+            except (StopIteration, TypeError):
+                pass
+        return entries

package/python/vendor/waste_collection_schedule/source/breckland_gov_uk.py

@@ -0,0 +1,95 @@
+import logging
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentExceptionMultiple,
+)
+
+TITLE = "Breckland Council"
+DESCRIPTION = "Source for breckland.gov.uk"
+URL = "https://www.breckland.gov.uk/mybreckland"
+TEST_CASES = {
+    "test1": {"postcode": "IP22 2LJ", "address": "glen travis"},
+    "test2": {"uprn": "10011977093"},
+}
+
+API_URL = "https://www.breckland.gov.uk/apiserver/ajaxlibrary"
+ICON_MAP = {
+    "Refuse Collection Service": Icons.GENERAL_WASTE,
+    "Recycling Collection Service": Icons.RECYCLING,
+    "Garden Waste Service": Icons.GARDEN,
+    "Food Waste Collection Service": Icons.BIO_KITCHEN,
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+headers = {"referer": URL}
+
+
+class Source:
+    def __init__(self, postcode=None, address=None, uprn=None):
+        self._postcode = postcode
+        self._address = address
+        self._uprn = uprn
+
+        if uprn is None and (postcode is None or address is None):
+            errors = []
+            if postcode is not None:
+                errors.append("address")
+            elif address is not None:
+                errors.append("postcode")
+            else:
+                errors = ["postcode", "address", "uprn"]
+            raise SourceArgumentExceptionMultiple(
+                errors, "specify postcode and address or just uprn"
+            )
+
+    def fetch(self):
+        if self._uprn is None:
+            json_data = {
+                "jsonrpc": "2.0",
+                "id": "",
+                "method": "Breckland.Whitespace.JointWasteAPI.GetSiteIDsByPostcode",
+                "params": {"postcode": self._postcode, "environment": "live"},
+            }
+
+            r = requests.post(API_URL, json=json_data, headers=headers)
+            r.raise_for_status()
+
+            json_response = r.json()
+
+            for key in json_response["result"]:
+                if self._address.lower() in key["name"].lower():
+                    self._uprn = key["uprn"]
+
+        if self._uprn is None:
+            raise Exception("Error querying calendar data")
+
+        json_data = {
+            "jsonrpc": "2.0",
+            "id": "",
+            "method": "Breckland.Whitespace.JointWasteAPI.GetBinCollectionsByUprn",
+            "params": {"uprn": self._uprn, "environment": "live"},
+        }
+
+        r = requests.post(API_URL, json=json_data, headers=headers)
+        r.raise_for_status()
+
+        waste = r.json()["result"]
+
+        entries = []
+
+        for data in waste:
+            entries.append(
+                Collection(
+                    datetime.strptime(
+                        data["nextcollection"], "%d/%m/%Y %H:%M:%S"
+                    ).date(),
+                    data["collectiontype"],
+                    ICON_MAP.get(data["collectiontype"]),
+                )
+            )
+
+        return entries

package/python/vendor/waste_collection_schedule/source/bridgend_gov_uk.py

@@ -0,0 +1,70 @@
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Bridgend County Borough Council"
+DESCRIPTION = "Source for bridgend.gov.uk"
+URL = "https://www.bridgend.gov.uk/"
+TEST_CASES: dict = {
+    "test_001": {"uprn": "100100479873"},
+    "test_002": {"uprn": 10032996088},
+    "test_003": {"uprn": "10090813443"},
+}
+ICON_MAP = {
+    "Refuse": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+}
+HEADERS: dict = {"user-agent": "Mozilla/5.0"}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION: dict = {
+    "en": "an easy way to discover your Unique Property Reference Number (UPRN) is by going to https://www.findmyaddress.co.uk/ and entering in your address details.",
+}
+PARAM_TRANSLATIONS: dict = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+    }
+}
+PARAM_DESCRIPTIONS: dict = {
+    "en": {
+        "uprn": "An easy way to discover your Unique Property Reference Number (UPRN) is by going to https://www.findmyaddress.co.uk/ and entering in your address details.",
+    }
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn)
+
+    def fetch(self) -> list[Collection]:
+        s = requests.Session()
+        r = s.get(
+            f"https://bridgendportal.azurewebsites.net/property/{self._uprn}",
+            headers=HEADERS,
+        )
+        soup: BeautifulSoup = BeautifulSoup(r.content, "html.parser")
+
+        tds: list = soup.find_all("td", {"class": ["service-name", "next-service"]})
+        waste_types: list = tds[0::2]
+        waste_dates: list = tds[1::2]
+
+        entries: list = []
+        for i in range(len(waste_types)):
+            waste_type = waste_types[i].text.split(" ")[0].replace("\n", "").strip()
+            waste_date = (
+                waste_dates[i]
+                .text.split(" ")[1]
+                .replace("\t", "")
+                .replace("Service\n", "")
+                .strip()
+            )
+            entries.append(
+                Collection(
+                    date=datetime.strptime(waste_date, "%d/%m/%Y").date(),
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+
+        return entries