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

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

@@ -0,0 +1,255 @@
+import re
+import unicodedata
+from datetime import date
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Clisson Sèvre et Maine Agglo"
+DESCRIPTION = (
+    "Source for Clisson Sèvre et Maine Agglo, the inter-municipal authority "
+    "responsible for waste collection in 18 municipalities of the "
+    "Loire-Atlantique department, France."
+)
+URL = "https://environnement.clissonsevremaine.fr"
+COUNTRY = "fr"
+
+SOURCE_CODEOWNERS = ["@JeyMuller"]
+
+CALENDAR_URL = (
+    "https://environnement.clissonsevremaine.fr"
+    "/dechets/collecte-des-dechets/calendrier-des-collectes"
+)
+CATEGORY_ARG = "tx_calendarize_calendar[customSearch][category]"
+MONTH_ARG = "tx_calendarize_calendar[month]"
+YEAR_ARG = "tx_calendarize_calendar[year]"
+
+# Number of months fetched, starting with the current one. The integration
+# refreshes once a day by default, so this stays well within reason.
+MONTHS_TO_FETCH = 12
+
+# Only used to advertise every municipality in the documentation and in the
+# configuration UI. The actual identifiers are always resolved live from the
+# drop-down on the website, so a renumbering upstream cannot break the source.
+COMMUNES = [
+    "Aigrefeuille-sur-Maine",
+    "Boussay",
+    "Château-Thébaud",
+    "Clisson",
+    "Clisson, rue Saint-Antoine",
+    "Gétigné - zone A",
+    "Gétigné - zone B",
+    "Gorges",
+    "Haute-Goulaine",
+    "La Haye-Fouassière - Zone A",
+    "La Haye-Fouassière - Zone B",
+    "La Planche",
+    "Maisdon-sur-Sèvre - zone 1",
+    "Maisdon-sur-Sèvre - zone 2",
+    "Maisdon-sur-Sèvre - zone 3",
+    "Monnières",
+    "Remouillé",
+    "Saint-Hilaire-de-Clisson - Zone A",
+    "Saint-Hilaire-de-Clisson - Zone B",
+    "Saint-Lumine-de-Clisson - Zone A",
+    "Saint-Lumine-de-Clisson - Zone B",
+    "St-Fiacre-sur-Maine",
+    "Vieillevigne",
+]
+
+EXTRA_INFO = [
+    {
+        "title": commune,
+        "url": URL,
+        "default_params": {"commune": commune},
+    }
+    for commune in COMMUNES
+]
+
+# A representative subset: a plain municipality, a zoned one, the street that
+# has its own round, and a three-zone municipality. Every entry costs
+# MONTHS_TO_FETCH requests, so testing all 23 zones would hammer the website.
+TEST_CASES = {
+    "Gorges": {"commune": "Gorges"},
+    "Maisdon-sur-Sèvre - zone 1": {"commune": "Maisdon-sur-Sèvre - zone 1"},
+    "La Haye-Fouassière - Zone B": {"commune": "La Haye-Fouassière - Zone B"},
+    "Clisson, rue Saint-Antoine": {"commune": "clisson, rue saint-antoine"},
+}
+
+ICON_MAP = {
+    "ordures menageres": Icons.GENERAL_WASTE,
+    "emballages": Icons.PLASTIC_PACKAGING,
+}
+DEFAULT_ICON = Icons.GENERAL_WASTE
+
+PARAM_TRANSLATIONS = {
+    "en": {"commune": "Municipality"},
+    "fr": {"commune": "Commune"},
+}
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "commune": (
+            "Your municipality, exactly as listed in the drop-down menu on the "
+            "collection calendar page, e.g. 'Maisdon-sur-Sèvre - zone 1'."
+        )
+    },
+    "fr": {
+        "commune": (
+            "Votre commune, telle qu'elle apparaît dans la liste déroulante de "
+            "la page du calendrier des collectes, par exemple "
+            "'Maisdon-sur-Sèvre - zone 1'."
+        )
+    },
+}
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        f"Open {CALENDAR_URL} and pick your municipality in the drop-down menu. "
+        "Use the wording shown there. Some municipalities are split into "
+        "several collection zones; the maps at the end of the downloadable PDF "
+        "calendars tell you which zone your street belongs to."
+    ),
+    "fr": (
+        f"Ouvrez {CALENDAR_URL} et choisissez votre commune dans la liste "
+        "déroulante. Reprenez le libellé affiché. Certaines communes sont "
+        "découpées en plusieurs zones de collecte ; les cartes situées à la fin "
+        "des calendriers PDF téléchargeables indiquent la zone de votre rue."
+    ),
+}
+
+FRENCH_MONTHS = [
+    "janvier",
+    "février",
+    "mars",
+    "avril",
+    "mai",
+    "juin",
+    "juillet",
+    "août",
+    "septembre",
+    "octobre",
+    "novembre",
+    "décembre",
+]
+
+# The waste type is spelled out in the calendar legend as "Collecte des
+# ordures ménagères" / "Collecte des emballages". Trim the lead-in so the
+# sensors read "Ordures ménagères" and "Emballages".
+COLLECTION_PREFIX = re.compile(r"^collecte\s+(?:des?|du|de\s+la|de\s+l')\s+", re.I)
+
+
+def _normalize(value: str) -> str:
+    """Lowercase, strip accents and reduce punctuation to single spaces."""
+    decomposed = unicodedata.normalize("NFKD", value)
+    without_accents = "".join(c for c in decomposed if not unicodedata.combining(c))
+    return re.sub(r"[^a-z0-9]+", " ", without_accents.lower()).strip()
+
+
+class Source:
+    def __init__(self, commune: str):
+        self._commune: str = commune.strip()
+
+    def _get_categories(self, session: requests.Session) -> dict[str, str]:
+        """Map every municipality label of the drop-down to its category id."""
+        r = session.get(CALENDAR_URL, timeout=30)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        select = soup.find("select", attrs={"name": CATEGORY_ARG})
+        if select is None:
+            raise RuntimeError("Could not find the municipality selector on the page")
+
+        return {
+            option.get_text(strip=True): value
+            for option in select.find_all("option")
+            if isinstance(value := option.get("value"), str) and value
+        }
+
+    def _parse_month(
+        self, session: requests.Session, category: str, year: int, month: int
+    ) -> list[Collection]:
+        params = {CATEGORY_ARG: category, YEAR_ARG: year, MONTH_ARG: month}
+        r = session.get(CALENDAR_URL, params=params, timeout=30)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        # Guard against the website ignoring the month/year arguments, which
+        # would otherwise yield the same month over and over again.
+        header = soup.find(id="month-header")
+        expected = _normalize(f"{FRENCH_MONTHS[month - 1]} {year}")
+        if header is None or expected not in _normalize(
+            header.get_text(" ", strip=True)
+        ):
+            return []
+
+        # The legend maps a CSS colour prefix to a human readable waste type.
+        legend: dict[str, str] = {}
+        for span in soup.select("#month-legend span[class*=_catheader_text]"):
+            span_classes = span.get("class") or []
+            if not isinstance(span_classes, list):
+                span_classes = [span_classes]
+            for css_class in span_classes:
+                if css_class.endswith("_catheader_text"):
+                    label = COLLECTION_PREFIX.sub("", span.get_text(strip=True))
+                    legend[css_class.removesuffix("_catheader_text")] = (
+                        label[:1].upper() + label[1:]
+                    )
+
+        entries: list[Collection] = []
+        for day_cell in soup.select("td.day.hasEvents"):
+            classes = day_cell.get("class") or []
+            if "not-current-month" in classes:
+                continue
+            day = int(day_cell.get_text(strip=True))
+
+            # A single day can carry several collections, one CSS colour each.
+            for css_class in classes:
+                if not css_class.endswith("_catheader_bullet"):
+                    continue
+                colour = css_class.removesuffix("_catheader_bullet")
+                if colour not in legend:
+                    continue
+                waste_type = legend[colour]
+                entries.append(
+                    Collection(
+                        date=date(year, month, day),
+                        t=waste_type,
+                        icon=ICON_MAP.get(_normalize(waste_type), DEFAULT_ICON),
+                    )
+                )
+        return entries
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update({"User-Agent": "Mozilla/5.0"})
+
+        categories = self._get_categories(session)
+        wanted = _normalize(self._commune)
+        category = next(
+            (
+                value
+                for label, value in categories.items()
+                if _normalize(label) == wanted
+            ),
+            None,
+        )
+        if category is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "commune", self._commune, sorted(categories)
+            )
+
+        today = date.today()
+        entries: list[Collection] = []
+        for offset in range(MONTHS_TO_FETCH):
+            month_index = today.month - 1 + offset
+            entries += self._parse_month(
+                session, category, today.year + month_index // 12, month_index % 12 + 1
+            )
+
+        if not entries:
+            raise RuntimeError(
+                f"No collection found for {self._commune}, "
+                "the website layout may have changed"
+            )
+        return entries

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

@@ -0,0 +1,175 @@
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Câmara Municipal de Lisboa"
+DESCRIPTION = "Source for waste collection schedules in Lisboa, Portugal."
+URL = "https://informacoeseservicos.lisboa.pt/servicos/dias-do-lixo"
+COUNTRY = "pt"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit https://informacoeseservicos.lisboa.pt/servicos/dias-do-lixo and search for your address on the map. The area name shown in the popup (e.g. 'Restelo', 'Madredeus') is the value to use.",
+}
+
+TEST_CASES = {
+    "Restelo": {"area_name": "Restelo"},
+    "Madredeus": {"area_name": "Madredeus"},
+    "Alvito": {"area_name": "Alvito"},
+    "Campo Ourique": {"area_name": "Campo Ourique"},
+}
+
+ICON_MAP = {
+    "Indiferenciado": Icons.GENERAL_WASTE,
+    "Papel e Cartão": Icons.PAPER,
+    "Embalagens": Icons.RECYCLING,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "area_name": "Name of the collection area (e.g. 'Restelo', 'Madredeus'). Visit https://informacoeseservicos.lisboa.pt/servicos/dias-do-lixo to find your area.",
+    },
+    "de": {
+        "area_name": "Name des Sammelgebiets (z.B. 'Restelo', 'Madredeus'). Besuchen Sie https://informacoeseservicos.lisboa.pt/servicos/dias-do-lixo um Ihr Gebiet zu finden.",
+    },
+    "fr": {
+        "area_name": "Nom de la zone de collecte (ex. 'Restelo', 'Madredeus'). Visitez https://informacoeseservicos.lisboa.pt/servicos/dias-do-lixo pour trouver votre zone.",
+    },
+    "it": {
+        "area_name": "Nome dell'area di raccolta (es. 'Restelo', 'Madredeus'). Visita https://informacoeseservicos.lisboa.pt/servicos/dias-do-lixo per trovare la tua area.",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "area_name": "Collection Area",
+    },
+    "de": {
+        "area_name": "Sammelgebiet",
+    },
+    "fr": {
+        "area_name": "Zone de collecte",
+    },
+    "it": {
+        "area_name": "Area di raccolta",
+    },
+}
+
+API_URL = "https://services.arcgis.com/1dSrzEWVQn5kHHyK/ArcGIS/rest/services/Amb_Reciclagem/FeatureServer/7/query"
+
+# Portuguese weekday abbreviations to Python weekday (0=Monday ... 6=Sunday)
+PT_WEEKDAYS = {
+    "2ª": 0,  # Segunda-feira (Monday)
+    "3ª": 1,  # Terça-feira (Tuesday)
+    "4ª": 2,  # Quarta-feira (Wednesday)
+    "5ª": 3,  # Quinta-feira (Thursday)
+    "6ª": 4,  # Sexta-feira (Friday)
+    "Sáb": 5,  # Sábado (Saturday)
+    "Dom": 6,  # Domingo (Sunday)
+}
+
+
+def _parse_days(days_str: str) -> list[int]:
+    """Parse Portuguese weekday string into list of Python weekday integers."""
+    if not days_str or days_str.strip() == "":
+        return []
+    weekdays = []
+    for part in days_str.replace("feira", "").split(","):
+        part = part.strip()
+        if part in PT_WEEKDAYS:
+            weekdays.append(PT_WEEKDAYS[part])
+    return weekdays
+
+
+def _generate_dates(weekdays: list[int], weeks: int = 26) -> list[date]:
+    """Generate collection dates for the given weekdays over N weeks."""
+    today = date.today()
+    dates = []
+    for weekday in weekdays:
+        days_ahead = (weekday - today.weekday()) % 7
+        next_date = today + timedelta(days=days_ahead)
+        for i in range(weeks):
+            dates.append(next_date + timedelta(weeks=i))
+    return sorted(dates)
+
+
+class Source:
+    def __init__(self, area_name: str):
+        self._area_name = area_name.strip()
+
+    def fetch(self) -> list[Collection]:
+        safe_name = self._area_name.replace("'", "''")
+        params = {
+            "where": f"NOME = '{safe_name}'",
+            "outFields": "NOME,DIAS_IND,DIAS_PAPEL,DIAS_EMBAL",
+            "returnGeometry": "false",
+            "f": "json",
+        }
+
+        r = requests.get(API_URL, params=params, timeout=30)
+        r.raise_for_status()
+
+        data = r.json()
+        features = data.get("features", [])
+
+        if not features:
+            # Fetch available area names for suggestions
+            suggestions = self._get_area_names()
+            raise SourceArgumentNotFoundWithSuggestions(
+                "area_name", self._area_name, suggestions
+            )
+
+        attrs = features[0]["attributes"]
+
+        entries: list[Collection] = []
+
+        # Indiferenciado (mixed/undifferentiated waste)
+        ind_days = _parse_days(attrs.get("DIAS_IND", ""))
+        for d in _generate_dates(ind_days):
+            entries.append(
+                Collection(date=d, t="Indiferenciado", icon=ICON_MAP["Indiferenciado"])
+            )
+
+        # Papel e Cartão (paper and cardboard)
+        papel_days = _parse_days(attrs.get("DIAS_PAPEL", ""))
+        for d in _generate_dates(papel_days):
+            entries.append(
+                Collection(date=d, t="Papel e Cartão", icon=ICON_MAP["Papel e Cartão"])
+            )
+
+        # Embalagens (packaging)
+        embal_days = _parse_days(attrs.get("DIAS_EMBAL", ""))
+        for d in _generate_dates(embal_days):
+            entries.append(
+                Collection(date=d, t="Embalagens", icon=ICON_MAP["Embalagens"])
+            )
+
+        return entries
+
+    @staticmethod
+    def _get_area_names() -> list[str]:
+        """Fetch all available area names for suggestions."""
+        params = {
+            "where": "DIAS_IND <> ' '",
+            "outFields": "NOME",
+            "returnGeometry": "false",
+            "returnDistinctValues": "true",
+            "orderByFields": "NOME",
+            "f": "json",
+        }
+        try:
+            r = requests.get(API_URL, params=params, timeout=30)
+            r.raise_for_status()
+            data = r.json()
+            return sorted(
+                {
+                    f["attributes"]["NOME"]
+                    for f in data.get("features", [])
+                    if f["attributes"].get("NOME")
+                }
+            )
+        except Exception:
+            return []

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

@@ -0,0 +1,58 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection
+from waste_collection_schedule.service.CMCityMedia import SERVICE_MAP
+
+TITLE = "CM City Media - Müllkalender"
+DESCRIPTION = "Source script for cmcitymedia.de"
+URL = "https://cmcitymedia.de"
+TEST_CASES = {
+    "Blankenheim - Bezirk F: Lindweiler, Rohr": {"hpid": 415, "district": 1371},
+    "Blankenheim": {"hpid": 415, "realmid": 41500},
+    "Oberstadion": {"hpid": 447, "district": 1349},
+}
+TEST_CASES.update({s["region"]: {"hpid": s["hpid"]} for s in SERVICE_MAP})
+
+
+def EXTRA_INFO():
+    return [
+        {"title": s["region"], "url": URL, "default_params": {"hpid": s["hpid"]}}
+        for s in SERVICE_MAP
+        if not s.get("disabled", False)
+    ]
+
+
+API_URL = "http://slim.cmcitymedia.de/v1/{}/waste/{}/dates"
+DATE_FORMAT = "%Y-%m-%d"
+
+
+class Source:
+    def __init__(self, hpid, realmid=None, district=None):
+        self.hpid = hpid
+        self.service = next(
+            (item for item in SERVICE_MAP if item["hpid"] == self.hpid), None
+        )
+        self.realmid = realmid if realmid else self.service["realm"]
+        self.district = district
+
+    def fetch(self):
+        entries = []
+
+        district_param = f"?district={self.district}" if self.district else ""
+        result = requests.get(
+            API_URL.format(self.hpid, self.service["realm"]) + district_param
+        )
+
+        result.raise_for_status()
+
+        for item in result.json()["result"][1]["items"]:
+            entries.append(
+                Collection(
+                    date=datetime.datetime.strptime(item["date"], DATE_FORMAT).date(),
+                    t=item["name"],
+                    icon=self.service["icons"][item["wastetype"]],
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,209 @@
+import re
+from datetime import date, datetime, timedelta
+from typing import TypedDict
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFound,
+)
+
+TITLE = "City of Cockburn"  # Title will show up in README.md and info.md
+DESCRIPTION = "Source script for cockburn.wa.gov.au"  # Describe your source
+# Insert url to service homepage. URL will show up in README.md and info.md
+URL = "https://www.cockburn.wa.gov.au"
+
+API_URL = "https://gis1.cockburn.wa.gov.au/webapiv2/PropertyInfoSearch/PropertyNo"
+
+TEST_CASES = {
+    "Thursday": {
+        "address": "23 Snowden St, Hammond Park WA 6164",
+    },
+    "Friday": {"address": "1 Eucalyptus Dr Hammond Park"},
+    # A postcode with no state, which is what most people type.
+    "Postcode without state": {"address": "23 Snowden Street HAMMOND PARK 6164"},
+    "Tuesday int": {"property_no": 6025742},
+    "Tuesday str": {"property_no": "6025742"},
+}
+
+ICON_MAP = {
+    "Rubbish": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Junk Waste": Icons.BULKY,
+    "Green Waste": Icons.GARDEN,
+    "Green Bin": Icons.ORGANIC,
+}
+
+HEADERS = {
+    "User-Agent": "Chrome/126.0.0.0 Safari/537.36 Edg/126.0.0.0",
+    "Accept": "application/xhtml+xml,text/json,application/xml",
+}
+
+
+class Collections(TypedDict):
+    type: str
+    dates: list[date]
+
+
+class Source:
+    def __init__(
+        self, address: str | None = None, property_no: str | int | None = None
+    ):
+        self.address: str | None = None
+        self.property_no: str | None = None
+
+        if not address and not property_no:
+            raise ValueError("Either address or property_no must be provided")
+
+        if address:
+            address = address.strip()
+            address = re.sub(" +", " ", address)
+            address = re.sub(",", "", address)
+            address = re.sub(" st ", " street ", address, flags=re.IGNORECASE)
+            address = re.sub(" hwy ", " highway ", address, flags=re.IGNORECASE)
+            address = re.sub(" ave ", " avenue ", address, flags=re.IGNORECASE)
+            address = re.sub(" rd ", " road ", address, flags=re.IGNORECASE)
+            address = re.sub(" ch ", " chase ", address, flags=re.IGNORECASE)
+            address = re.sub(" lp ", " loop ", address, flags=re.IGNORECASE)
+            address = re.sub(" dr ", " drive ", address, flags=re.IGNORECASE)
+            address = re.sub(
+                r"western australia (\d{4})", "WA \\1", address, flags=re.IGNORECASE
+            )
+            address = re.sub(r" wa (\d{4})", "  WA  \\1", address, flags=re.IGNORECASE)
+            # The search wants the state spelled between suburb and postcode
+            # ("HAMMOND PARK WA 6164"); a trailing postcode with no state at
+            # all matches nothing, so put the state in.
+            if not re.search(r"\bwa\b", address, flags=re.IGNORECASE):
+                address = re.sub(r"\s+(\d{4})\s*$", "  WA  \\1", address)
+            self.address = address
+            self.search_method = "address"
+
+        if property_no:
+            self.property_no = str(property_no)
+            self.search_method = "property_no"
+
+    def collect_dates(self, start_date, weeks):
+        dates = []
+        dates.append(start_date)
+        for _ in range(1, 4 // weeks):
+            start_date = start_date + timedelta(days=(weeks * 7))
+            dates.append(start_date)
+        return dates
+
+    def _search(self, query: str, search_method: str) -> list[dict]:
+        search_value = re.sub(r"\s+", "+", query.strip())
+        r = requests.get(
+            f"{API_URL}?q={search_value}&search_method={search_method}",
+            headers=HEADERS,
+        )
+        r.raise_for_status()
+        payload = r.json()
+        return payload if isinstance(payload, list) else []
+
+    def _search_address(self) -> list[dict]:
+        """Find the property, retrying without the state and postcode.
+
+        The search is stricter about what follows the street than about the
+        street itself, and resolves fine without a state and postcode, so a
+        trailing "WA 6164" is better dropped than sent when it matches nothing.
+        """
+        address = self.address or ""
+        attempts = [address]
+        without_state = re.sub(
+            r"\s+wa\s+\d{4}\s*$", "", address, flags=re.IGNORECASE
+        ).strip()
+        if without_state and without_state != address:
+            attempts.append(without_state)
+
+        for attempt in attempts:
+            results = self._search(attempt, "address")
+            if results:
+                return results
+
+        raise SourceArgumentNotFound(
+            "address",
+            address,
+            "Cockburn did not recognise that address. Check the street number "
+            "and name, and write the street type out in full (Street, not St).",
+        )
+
+    def extract_date(self, text: str) -> datetime | None:
+        # Define the pattern for the date format DD-MMM-YYYY
+        pattern = r"\d{1,2}-\w{3}-\d{4}"
+        # Search for the pattern in the text
+        match = re.search(pattern, text)
+
+        # If a match is found, return the matched string (the date)
+        if match:
+            original_date = match.group()
+            # Convert the matched string to a datetime object
+            formatted_date = datetime.strptime(original_date, "%d-%b-%Y")
+            return formatted_date
+        return None
+
+    def fetch(self) -> list[Collection]:
+        entries: list[Collection] = []
+
+        # property_no identifies the property exactly, so prefer it when both
+        # arguments are given, as the source did before.
+        if self.property_no:
+            results = self._search(self.property_no, "property_no")
+            if not results:
+                raise SourceArgumentNotFound("property_no", self.property_no)
+            data = results[0]
+        else:
+            results = self._search_address()
+            if len(results) > 1:
+                suggestions = [
+                    match["Address"] for match in results if match.get("Address")
+                ]
+                raise SourceArgAmbiguousWithSuggestions(
+                    "address", self.address, suggestions[:10]
+                )
+            data = results[0]
+
+        if data:
+            # Convert the bin day to a date
+            date_rubbish = datetime.today()
+            while date_rubbish.strftime("%A") != data["BinDay"]:
+                date_rubbish += timedelta(days=1)
+
+            # Create bin collection date object
+            bin_dates = [date_rubbish.date()]
+
+            # Create green bin collection date object removing the unneeded text
+            grn_bin_datetime = self.extract_date(data["GardenWaste"])
+            grn_bin_dates = [grn_bin_datetime.date()] if grn_bin_datetime else []
+
+            # Format the Junk Waste collection dates
+            jnk_dates = [
+                datetime.strptime(data["JunkWhite1"], "%d-%b-%Y").date(),
+                datetime.strptime(data["JunkWhite2"], "%d-%b-%Y").date(),
+            ]
+
+            # Format the Green Waste collection dates
+            grn_waste_dates = [
+                datetime.strptime(data["GreenWaste1"], "%d-%b-%Y").date(),
+                datetime.strptime(data["GreenWaste2"], "%d-%b-%Y").date(),
+            ]
+
+            collections: list[Collections] = []
+            collections.append({"type": "Rubbish", "dates": bin_dates})
+            collections.append({"type": "Recycling", "dates": bin_dates})
+            collections.append({"type": "Junk Waste", "dates": jnk_dates})
+            collections.append({"type": "Green Waste", "dates": grn_waste_dates})
+            collections.append({"type": "Green Bin", "dates": grn_bin_dates})
+
+            for collection in collections:
+                icon = ICON_MAP.get(collection["type"])
+                for d in collection["dates"]:
+                    entries.append(
+                        Collection(
+                            date=d,
+                            t=collection["type"],
+                            icon=icon,
+                        )
+                    )
+
+        return entries