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

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

@@ -0,0 +1,138 @@
+import json
+import re
+from datetime import date, datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Porirua City"
+DESCRIPTION = "Source for Porirua City."
+URL = "https://poriruacity.govt.nz/"
+TEST_CASES = {
+    "6 Ration Lane, Whitby, Porirua City 5024": {
+        "address": "6 Ration Lane Whitby, Porirua City 5024"
+    },
+    "104 Main Road, Titahi Bay, Porirua City 5022": {
+        "address": "104 Main Road Titahi Bay, Porirua City 5022"
+    },
+    "Address single-comma test": {
+        "address": "104 Main Road Titahi Bay, Porirua City 5022"
+    },
+}
+
+
+ICON_MAP = {
+    "rubbish": Icons.GENERAL_WASTE,
+    "glass": Icons.GLASS,
+    "mixed": Icons.RECYCLING,
+}
+
+JS_URL = "https://storage.googleapis.com/pcc-static-v6/pccapp/dist/assets/index.js?v=fd27232ae8d640d2a7ab8eb0a8658fe9"
+
+ZONES_REGEX = re.compile(r"const\s?Xs\s?=\s?\{.*?\};", re.DOTALL)
+COLLECTIONS_MAP_REGEX = re.compile(r"collections:\s?\{(\w+:\s?\[.*?\],?)+\}", re.DOTALL)
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address: str = address
+        # 2025 endpoint change means street names no longer have a "," separator
+        # To preserve old configs, remove the first one if there are 2 or more.
+        if self._address.count(",") > 1:
+            self._address = self._address.replace(",", "", 1)
+
+    @staticmethod
+    def get_js_infos() -> tuple[dict[str, list[str]], dict[str, list[str]]]:
+        r = requests.get(JS_URL)
+        zones_js_match = ZONES_REGEX.search(r.text)
+        if not zones_js_match:
+            raise Exception(
+                "Zones not found probably due to a change in the websites javascript"
+            )
+        zones_js = zones_js_match.group(0)
+        # const Xs={zone1:[new Date(2022,7,22),new Date(2022,7,23),new Date(2022,7,24),new Date(2022,7,25),new Date(2022,7,26)],zone2:[new Date(2022,7,8),new Date(2022,7,9),new Date(2022,7,10),new Date(2022,7,11),new Date(2022,7,12)],zone3:[new Date(2022,7,1),new Date(2022,7,2),new Date(2022,7,3),new Date(2022,7,4),new Date(2022,7,5)],zone4:[new Date(2022,7,15),new Date(2022,7,16),new Date(2022,7,17),new Date(2022,7,18),new Date(2022,7,19)]};
+        zones_js = zones_js.replace("const Xs=", "").replace(";", "")
+        # replace new Date(2022,7,22) with "2022-08-22"
+        zones_js = re.sub(
+            r"new Date\((\d{4}),(\d{1,2}),(\d{1,2})\)",
+            lambda m: (
+                f'"{m.group(1)}-{str(int(m.group(2)) + 1).zfill(2)}-{m.group(3).zfill(2)}"'
+            ),
+            zones_js,
+        )
+        # replace zone1 with "zone1"
+        zones_js = re.sub(r"zone(\d+)", r'"zone\1"', zones_js)
+        ZONES: dict[str, list[str]] = json.loads(zones_js)
+        collections_map_reg_result = COLLECTIONS_MAP_REGEX.search(r.text)
+        if not collections_map_reg_result:
+            raise Exception(
+                "Collections map not found probably due to a change in the websites javascript"
+            )
+        collections_map_str = (
+            collections_map_reg_result.group(0).replace("collections:", "").strip()
+        )
+
+        # replace glass with "glass"
+        collections_map_str = re.sub(r"(\w+):", r'"\1":', collections_map_str)
+        COLLECTIONS_MAP: dict[str, list[str]] = json.loads(collections_map_str)
+        return ZONES, COLLECTIONS_MAP
+
+    def fetch(self) -> list[Collection]:
+        ZONES, COLLECTIONS_MAP = self.get_js_infos()
+        url = "https://maps.poriruacity.govt.nz/server/rest/services/Property/PropertyAdminExternal/MapServer/5/query"
+        params: dict[str, str | int] = {
+            "where": f"lower(address) = '{self._address.lower()}'",
+            "f": "pjson",
+            "outFields": "Address,OBJECTID,Collection_Day,Collection_Zone",
+            "returnGeometry": "false",
+            "resultRecordCount": 20,
+            "orderByFields": "Address",
+        }
+
+        r = requests.get(url, params=params)
+
+        data = r.json()
+        if "features" not in data or not data["features"]:
+            raise SourceArgumentNotFound("address", self._address)
+
+        feature = data["features"][0]
+        properties = feature["attributes"]
+
+        today = date.today()
+
+        col_day = properties["Collection_Day"]
+        col_zone = properties["Collection_Zone"].replace(" ", "").lower()
+
+        next_col_day = None
+        for i in range(1, 8, 1):
+            if (today + timedelta(days=i)).strftime("%A") == col_day:
+                next_col_day = today + timedelta(days=i)
+                break
+        if not next_col_day:
+            raise SourceArgumentNotFound("address", self._address)
+
+        z = ZONES[col_zone][next_col_day.weekday()]
+
+        z_date = datetime.strptime(z, "%Y-%m-%d")
+
+        next_days = (
+            next_col_day,
+            next_col_day + timedelta(days=7),
+            next_col_day + timedelta(days=14),
+        )
+
+        qs = ["glass", "rubbish", "mixed", "rubbish"]
+        entries: list[Collection] = []
+        for d in next_days:
+            d_time = datetime(d.year, d.month, d.day)
+            unix_time = int(d_time.timestamp() * 1000)
+            z_date_unix_time = int(z_date.timestamp() * 1000)
+            js_r = int(round((unix_time - z_date_unix_time) / 864e5) // 7)
+            js_i = abs(js_r) % 4
+            map_idx = qs[js_i]
+            relevant_types = COLLECTIONS_MAP[map_idx]
+            for col_type in relevant_types:
+                entries.append(Collection(d, col_type, ICON_MAP.get(col_type)))
+
+        return entries

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

@@ -0,0 +1,224 @@
+import logging
+import re
+from datetime import datetime
+
+import requests
+import urllib3
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+# With verify=True the POST fails due to a SSLCertVerificationError.
+# Using verify=False works, but is not ideal. The following links may provide a better way of dealing with this:
+# https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html#ssl-warnings
+# https://urllib3.readthedocs.io/en/1.26.x/user-guide.html#ssl
+# This line suppresses the InsecureRequestWarning when using verify=False
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+TITLE = "Port Adelaide Enfield, South Australia"
+DESCRIPTION = "Source for City of Port Adelaide Enfield, South Australia."
+URL = "https://ecouncil.portenf.sa.gov.au/"
+TEST_CASES = {
+    "Broadview, Regency Road, 565 ": {
+        "suburb": "Broadview",
+        "street": "Regency Road",
+        "house_number": 565,
+        "unit_number": "",
+    },
+    "48 Floriedale Rd ": {
+        "suburb": "Greenacres",
+        "street": "Floriedale Rd",
+        "house_number": "48",
+    },
+    "24 Margaret Terrace": {
+        "suburb": "Rosewater",
+        "street": "Margaret Terrace",
+        "house_number": "24",
+    },
+    "Addison Road 91 with unit": {
+        "suburb": "Rosewater",
+        "street": "Addison Road",
+        "house_number": 91,
+        "unit_number": 2,
+    },
+}
+
+ICON_MAP = {
+    "general-waste bin": Icons.GENERAL_WASTE,
+    "organics bin": Icons.ORGANIC,
+    "recycling bin": Icons.RECYCLING,
+}
+
+LOGGER = logging.getLogger(__name__)
+
+API_URL = "https://ecouncil.portenf.sa.gov.au/public/propertywastedates/public.aspx"
+
+
+class Source:
+    def __init__(
+        self,
+        suburb: str,
+        street: str,
+        house_number: str | int,
+        unit_number: str | int = "",
+    ):
+        self._suburb: str = suburb
+        self._street: str = street
+        self._house_number: str = str(house_number)
+        self._unit_number: str = str(unit_number)
+
+    def __set_args(
+        self, soup: BeautifulSoup, event_taget=None, additional: dict | None = None
+    ) -> dict:
+        if additional is None:
+            additional = {}
+        args = {
+            "ctl00$MainContent$txtSuburb": self._suburb,
+            "ctl00$MainContent$txtStreetName": self._street,
+            "ctl00$MainContent$txtHouseNumber": self._house_number,
+            "ctl00$MainContent$txtUnitNumber": self._unit_number,
+        }
+        if event_taget is not None:
+            args["__EVENTTARGET"] = event_taget
+
+        for hidden_val in soup.find_all("input", {"type": "hidden"}):
+            args[hidden_val["name"]] = hidden_val["value"]
+
+        for key, value in additional.items():
+            args[key] = value
+        return args
+
+    def fetch(self):
+        session = requests.Session()
+
+        # get First page
+        r = session.get(API_URL, verify=False)
+        r.raise_for_status()
+
+        # extractt arguments
+        args = self.__set_args(
+            BeautifulSoup(r.text, "html.parser"),
+            event_taget="ctl00$MainContent$btnSearch",
+        )
+
+        r = session.post(API_URL, data=args, verify=False)
+        r.raise_for_status()
+
+        # get page to select an address
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        selectable = soup.find_all(
+            "a", {"class": "anchor-button small"}, string="Select"
+        )
+
+        if len(selectable) == 0:
+            raise ValueError("No address found")
+        selected = selectable[0]
+
+        # If multiple addresses are found, try to find the one that matches the input and warn if there are multiple or none matches
+        if len(selectable) > 1:
+            found = [
+                " ".join(
+                    [y.text for y in x.parent.parent.find_all("td")[1].find_all("span")]
+                )
+                for x in selectable
+            ]
+            using_index = 0
+
+            match = False
+
+            for index, entry in enumerate(found):
+                entry = entry.lower().strip().replace("  ", "")
+                if (
+                    self._house_number.lower().strip().replace("  ", "") in entry
+                    and self._street.lower().strip().replace("  ", "") in entry
+                    and self._suburb.lower().strip().replace("  ", "") in entry
+                    and self._unit_number.lower().strip().replace("  ", "") in entry
+                ):
+                    if match:
+                        LOGGER.warning(
+                            f"Multiple addresses found, using first one \nfound:{', '.join(found[:10])}{'...' if len(found) >= 10 else ''} \nusing:{found[using_index]}"
+                        )
+                        break
+                    using_index = index
+                    match = True
+            if not match:
+                LOGGER.warning(
+                    f"no perfect address match found, using:{found[using_index]}"
+                )
+
+        # request first address
+        args = self.__set_args(
+            soup,
+            event_taget="ctl00$MainContent$gvPropertyResults$ctl02$btnSelect",
+            additional={selected["href"].split("'")[1]: ""},
+        )
+        r = session.post(API_URL, data=args, verify=False)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        cal_header = soup.find("th", {"class": "header-month"}).find("span").text
+
+        month_range = cal_header.split("-")
+        from_month = month_range[0].strip()
+
+        to_month, to_year, from_year = None, None, None
+        if len(month_range) > 1:
+            to_month = month_range[1].strip().split(" ")[0]
+            to_year = from_year = month_range[1].strip().split(" ")[1]
+
+        # if main month contains a year, set it (maybe happens in december???)
+        if len(from_month.split(" ")) > 1:
+            from_year = from_month.split(" ")[1]
+            from_month = from_month.split(" ")[0]
+
+        # Single-month calendar (no "other month" range)
+        if to_month is None:
+            if from_year is None:
+                from_year = str(datetime.now().year)
+            main_month = from_month
+            main_year = from_year
+            other_month = from_month
+            other_year = from_year
+        else:
+            today_div = soup.find("table", id="cal").find("td", class_="today")
+
+            # if other-month is to_month
+            if (
+                "other-month" in today_div.attrs["class"]
+                and datetime.now().strftime("%B") == to_month
+            ) or (
+                "main-month" in today_div.attrs["class"]
+                and datetime.now().strftime("%B") == from_month
+            ):
+                main_month, other_month = from_month, to_month
+                main_year, other_year = from_year, to_year
+            else:  # if other-month is from_month
+                main_month, other_month = to_month, from_month
+                main_year, other_year = to_year, from_year
+
+        entries = []
+
+        calendar = soup.find("table", {"class": "collection-day-calendar"})
+        # Iterate over all days with pickups
+        for pickup in calendar.find_all(
+            "div", {"class": re.compile(r"pickup|next-pickup")}
+        ):
+            parent_td = pickup.parent
+            month = (
+                main_month if "main-month" in parent_td.attrs["class"] else other_month
+            )
+            year = main_year if "main-month" in parent_td.attrs["class"] else other_year
+            day = parent_td.find("div", {"class": "daynumber"}).text
+
+            # Iterate over all pickup container types for this day
+            for container in pickup.find_all("div", {"class": "bin-container"}):
+                container_type = " ".join(container.find("div").attrs["class"])
+                container_icon = ICON_MAP.get(container_type)
+
+                date = datetime.strptime(f"{year}-{month}-{day}", "%Y-%B-%d").date()
+                entries.append(
+                    Collection(date=date, t=container_type, icon=container_icon)
+                )
+
+        return entries

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

@@ -0,0 +1,107 @@
+from datetime import datetime, timedelta
+
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.IntraMaps import (
+    IntraMapsError,
+    IntraMapsSearchError,
+    MapsClient,
+    MapsClientConfig,
+    extract_panel_fields,
+)
+
+TITLE = "City of Port Phillip"
+DESCRIPTION = "Source for City of Port Phillip waste collection."
+URL = "https://www.portphillip.vic.gov.au"
+COUNTRY = "au"
+
+TEST_CASES = {
+    "9 Spray Street Elwood": {"address": "9 Spray Street Elwood"},
+    "99A Bridport Street Albert Park": {"address": "99A Bridport Street Albert Park"},
+    "1 Beach Street Port Melbourne": {"address": "1 Beach Street Port Melbourne"},
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "FOGO": Icons.BIO_KITCHEN,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your street address including suburb "
+    "(e.g. '9 Spray Street Elwood'). "
+    "Search at https://www.portphillip.vic.gov.au/council-services/waste-recycling-and-rubbish/bins-and-collection-services",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address with suburb (e.g. '9 Spray Street Elwood')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+INTRAMAPS_CONFIG = MapsClientConfig(
+    base_url="https://copp.spatial.t1cloud.com",
+    instance="spatial/IntraMaps",
+    config_id="15f21a6e-3939-4b70-b531-21309d0624de",
+    project="3bf491de-10d3-42f0-be95-716bd4263526",
+    lite_config_id="b0b09c2e-b120-4a07-84f3-fd8c1dbecb6e",
+    module_id="e948c801-51b4-452a-87b5-2627e0e3e01a",
+    selection_layer_filter="a6b80f49-ccbc-4b7c-8560-c1c15ac6164c",
+)
+
+WEEKDAYS = {
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+    "saturday": 5,
+    "sunday": 6,
+}
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        try:
+            with MapsClient(INTRAMAPS_CONFIG) as client:
+                result = client.select_address(self._address)
+        except IntraMapsSearchError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        response = result["response"]
+        if not isinstance(response, dict):
+            raise IntraMapsError("Unexpected response format from IntraMaps")
+
+        fields = extract_panel_fields(response)
+        if not fields:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # "Bin Collection" is a weekday name, e.g. "Wednesday". The council
+        # collects general waste, recycling and FOGO bins together, once a
+        # week, on the same day.
+        bin_day = fields.get("Bin Collection", "").strip()
+        weekday = WEEKDAYS.get(bin_day.lower())
+        if weekday is None:
+            raise SourceArgumentNotFound("address", self._address)
+
+        today = datetime.now().date()
+        days_ahead = (weekday - today.weekday()) % 7
+        next_date = today + timedelta(days=days_ahead)
+
+        entries: list[Collection] = []
+        for waste_type, icon in ICON_MAP.items():
+            entries.extend(
+                Collection(date=next_date + timedelta(weeks=i), t=waste_type, icon=icon)
+                for i in range(26)
+            )
+
+        return entries

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

@@ -0,0 +1,78 @@
+import time
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+
+TITLE = "Portsmouth City Council"
+DESCRIPTION = "Source for waste collection services for Portsmouth City Council"
+URL = "https://www.portsmouth.gov.uk"
+TEST_CASES = {
+    "Fawcett Road - number": {"uprn": 1775027540},
+    "Fawcett Road - string": {"uprn": "1775027540"},
+    "Westbourne Road - number": {"uprn": 1775084532},
+    "Westbourne Road - string": {"uprn": "1775084532"},
+}
+
+API_URLS = {
+    "session": "https://my.portsmouth.gov.uk/en/AchieveForms/?form_uri=sandbox-publish://AF-Process-26e27e70-f771-47b1-a34d-af276075cede/AF-Stage-cd7cc291-2e59-42cc-8c3f-1f93e132a2c9/definition.json&redirectlink=%2F&cancelRedirectLink=%2F",
+    "auth": "https://my.portsmouth.gov.uk/authapi/isauthenticated?uri=https%3A%2F%2Fmy.portsmouth.gov.uk%2Fen%2FAchieveForms%2F%3Fform_uri%3Dsandbox-publish%3A%2F%2FAF-Process-26e27e70-f771-47b1-a34d-af276075cede%2FAF-Stage-cd7cc291-2e59-42cc-8c3f-1f93e132a2c9%2Fdefinition.json%26redirectlink%3D%252F%26cancelRedirectLink%3D%252F&hostname=my.portsmouth.gov.uk&withCredentials=true",
+    "schedule": "https://my.portsmouth.gov.uk/apibroker/runLookup?id=5e81ed10c0241&repeat_against=&noRetry=true&getOnlyTokens=undefined&log_id=&app_name=AF-Renderer::Self&_=1682697046055&sid=93c73ba547e8c23e85a50a1de67a5ca7",
+}
+
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+
+
+class Source:
+    def __init__(self, uprn: str):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        s = requests.Session()
+
+        # This request sets up the cookies
+        r0 = s.get(API_URLS["session"], headers=HEADERS)
+        r0.raise_for_status()
+
+        # This request gets the session key from the PHPSESSID (in the cookies)
+        authRequest = s.get(API_URLS["auth"], headers=HEADERS)
+        authData = authRequest.json()
+        sessionKey = authData["auth-session"]
+        now = time.time_ns() // 1_000_000
+
+        # now query using the uprn
+        payload = {"formValues": {"Section 1": {"col_uprn": {"value": self._uprn}}}}
+        scheduleRequest = s.post(
+            API_URLS["schedule"] + "&_" + str(now) + "&sid=" + sessionKey,
+            headers=HEADERS,
+            json=payload,
+        )
+        data = scheduleRequest.json()["integration"]["transformed"]["rows_data"]["0"]
+
+        rubbishDates = data["listRefDatesHTML"].split("<p>")[0].split("<br />")
+        recyclingDates = data["listRecDatesHTML"].split("<p>")[0].split("<br />")
+
+        entries = []
+        for date in rubbishDates:
+            if len(date) > 0:
+                entries.append(
+                    Collection(
+                        date=datetime.strptime(date.rstrip("* "), "%A %d %B %Y").date(),
+                        t="refuse bin",
+                        icon="mdi:trash-can",
+                    )
+                )
+
+        for date in recyclingDates:
+            if len(date) > 0:
+                entries.append(
+                    Collection(
+                        date=datetime.strptime(date.rstrip("* "), "%A %d %B %Y").date(),
+                        t="recycling bin",
+                        icon="mdi:recycle",
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,136 @@
+import datetime
+import json
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Port Stephens Council"
+DESCRIPTION = "Source for Port Stephens Council waste collection."
+URL = "https://www.portstephens.nsw.gov.au/"
+
+TEST_CASES = {
+    "randomHouse1": {
+        "suburb": "Soldiers Point",
+        "street_name": "Lyndel Close",
+        "street_number": "2",
+    },
+    "randomHouse2": {
+        "suburb": "Bobs Farm",
+        "street_name": "Marsh Road",
+        "street_number": 322,
+    },
+}
+
+
+API_BASE_URL = "https://port-stephens.waste-info.com.au/api/v1/"
+
+API_URLS = {
+    "Localities": f"{API_BASE_URL}localities.json",
+    "Streets": f"{API_BASE_URL}streets.json",
+    "Properties": f"{API_BASE_URL}properties.json",
+    "Collection": f"{API_BASE_URL}properties/",
+}
+
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+
+ICON_MAP = {
+    "general": Icons.GENERAL_WASTE,
+    "special": Icons.GENERAL_WASTE,
+    "recycle": Icons.RECYCLING,
+    "organic": Icons.ORGANIC,
+}
+
+ROUNDS = {
+    "general": "General Waste",
+    "recycle": "Recycling",
+    "organic": "Green Waste",
+}
+
+TRACKED_EVENTS = ["general", "recycle", "organic", "special"]
+
+
+def get_id(
+    s: requests.Session,
+    url_key: str,
+    val_key: str,
+    name: str,
+    params: dict | None = None,
+    init_param_name: str | None = None,
+):
+    if params is None:
+        params = {}
+    response = s.get(API_URLS[url_key], params=params, headers=HEADERS)
+    data = json.loads(response.text)
+    for val in data[val_key]:
+        if val["name"].lower() == name.lower():
+            return val["id"]
+    if init_param_name is None:
+        raise ValueError(f"Could not find {name} in {url_key}")
+    raise SourceArgumentNotFoundWithSuggestions(
+        init_param_name, name, [x["name"] for x in data[val_key]]
+    )
+
+
+class Source:
+    def __init__(self, suburb: str, street_name: str, street_number: str):
+        self.suburb = suburb
+        self.street_name = street_name
+        self.street_number = street_number
+        self.street_address = f"{street_number} {street_name} {suburb}".lower()
+
+    def fetch(self):
+        locality_id = 0
+        street_id = 0
+        property_id = 0
+        this_year = datetime.datetime.now().year
+        last_year = this_year - 1
+        entries = []
+
+        request = requests.Session()
+        locality_id = get_id(
+            request, "Localities", "localities", self.suburb, init_param_name="suburb"
+        )
+        street_id = get_id(
+            request,
+            "Streets",
+            "streets",
+            self.street_name,
+            params={"locality": locality_id},
+            init_param_name="street_name",
+        )
+        property_id = get_id(
+            request,
+            "Properties",
+            "properties",
+            self.street_address,
+            params={"street": street_id},
+            init_param_name="street_number",
+        )
+
+        property_url = API_URLS["Collection"] + str(property_id) + ".json"
+        params = {
+            "start": f"{last_year}-12-31T13:00:00.000Z",
+            "end": f"{this_year}-12-30T13:00:00.000Z",
+        }
+        collection_data = request.get(property_url, params=params, headers=HEADERS)
+        collections = json.loads(collection_data.text)
+        for entry in collections:
+            if "property" in entry:
+                continue
+            event_type = entry["event_type"]
+            date = datetime.datetime.strptime(entry["start"], "%Y-%m-%d").date()
+            if event_type == "special":
+                event_name = entry["name"]
+            else:
+                event_name = ROUNDS.get(event_type)
+            if event_type in TRACKED_EVENTS:
+                entries.append(
+                    Collection(date=date, t=event_name, icon=ICON_MAP.get(event_type))
+                )
+
+        return entries