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

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

@@ -0,0 +1,143 @@
+import json
+import logging
+import re
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFound,
+    SourceArgumentRequired,
+)
+
+TITLE = "Łódź"
+DESCRIPTION = "Source for Łódź city garbage collection"
+URL = "https://kartalodzianina.pl"
+TEST_CASES = {
+    "Podchorążych 1 (Letniskowa)": {
+        "street": "Podchorążych",
+        "house_number": "1",
+        "building_type": 3,
+    },
+    "Piotrkowska 104 (Wielorodzinna)": {
+        "street": "Piotrkowska",
+        "house_number": "104",
+        "building_type": 2,
+    },
+    "Partyzantów 1 (Jednorodzinna)": {
+        "street": "Partyzantów",
+        "house_number": "1",
+        "building_type": 1,
+    },
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+ICON_MAP = {
+    "Szkło": Icons.GLASS,
+    "Papier": Icons.PAPER,
+    "Metale i tworzywa sztuczne": Icons.METAL,
+    "Resztkowe": Icons.GENERAL_WASTE,
+    "Mokre Bio": Icons.ORGANIC,
+}
+
+
+class Source:
+    def __init__(self, street: str, house_number: str, building_type: int = 1):
+        """Initialize the source.
+
+        :param street: Street name (e.g., "Adwentowicza")
+        :param house_number: House number (e.g., "1", "2a")
+        :param building_type: Building type: 1 (single-family), 2 (multi-family), 3 (summer house). Default is 1.
+        """
+        self.street = street
+        self.house_number = str(house_number)
+        self.building_type = building_type
+
+    def fetch(self) -> list[Collection]:
+        # Validate required arguments
+        if not self.street:
+            raise SourceArgumentRequired("street", "A street name is required")
+        if not self.house_number:
+            raise SourceArgumentRequired("house_number", "A house number is required")
+        if str(self.building_type) not in ["1", "2", "3"]:
+            raise SourceArgumentException(
+                "building_type",
+                f"Invalid value '{self.building_type}': Must be 1 (single-family), 2 (multi-family), or 3 (summer house).",
+            )
+
+        # GET request parameters for the Karta Łodzianina API
+        params: dict[str, str | int] = {
+            "iframe": "",
+            "actionPerformedWyszukajTyp": "",
+            "odpad": "",
+            "ulica": self.street,
+            "nrDomu": self.house_number,
+            "idMiejscowosci": "undefined",
+            "rodzajZabudowy": self.building_type,
+        }
+
+        try:
+            response = requests.get(f"{URL}/wywoz-odpadow", params=params, timeout=30)
+            response.raise_for_status()
+            html_content = response.text
+        except requests.RequestException as e:
+            raise ValueError(f"Error fetching data from Łódź API: {e}") from e
+
+        # Check if the address exists in the database
+        if "Brak dostępnego harmonogramu dla wskazanego adresu" in html_content:
+            # Raise predefined custom exception with details
+            raise SourceArgumentNotFound(
+                "street/house_number/building_type",
+                f"{self.street} {self.house_number} ({self.building_type})",
+            )
+
+        # Extracting the JSON array hidden in the JavaScript code (FullCalendar library)
+        # Using re.DOTALL so the regex works across multiple lines
+        pattern = r"events:\s*(\[.*?\])\s*,\s*eventDidMount"
+        match = re.search(pattern, html_content, re.DOTALL)
+
+        if not match:
+            raise SourceArgumentNotFound(
+                "Page retrieved, but calendar data (JSON) was not found."
+            )
+
+        json_data = match.group(1)
+
+        try:
+            events = json.loads(json_data)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Error parsing the JSON schedule: {e}") from e
+
+        entries = []
+
+        # Iterate over each extracted event
+        for event in events:
+            waste_type = event.get("title")
+            date_str = event.get("start")
+
+            if not waste_type or not date_str:
+                continue
+
+            try:
+                # The date format in JSON is always YYYY-MM-DD
+                event_date = datetime.strptime(date_str, "%Y-%m-%d").date()
+
+                entries.append(
+                    Collection(
+                        date=event_date,
+                        t=waste_type,
+                        icon=ICON_MAP.get(waste_type, "mdi:trash-can"),
+                    )
+                )
+            except ValueError:
+                _LOGGER.warning(f"Ignored invalid date format: {date_str}")
+
+        if not entries:
+            raise SourceArgumentExceptionMultiple(
+                ["street", "house_number", "building_type"],
+                f"No collection dates found for {self.street} {self.house_number} ({self.building_type}) (calendar returned no usable events).",
+            )
+        return entries

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

@@ -0,0 +1,78 @@
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Logan City Council"
+DESCRIPTION = "Source for Logan City Council rubbish collection."
+URL = "https://www.logan.qld.gov.au"
+COUNTRY = "au"
+TEST_CASES = {
+    "Lee Naki's Takeaway": {"property_location": "12 Ashton Street Kingston"},
+    "LCC Administration Centre": {
+        "property_location": "150 Wembley Road Logan Central"
+    },
+    "Rochedale South (with green waste)": {
+        "property_location": "53 Wendron Street Rochedale South"
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Enter your street address as used on the Logan City Council MyLogan tool "
+        "(https://www.logan.qld.gov.au/MyLogan), for example "
+        "'12 Ashton Street Kingston'."
+    )
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "property_location": "Street Address",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "property_location": (
+            "Your street address, e.g. '12 Ashton Street Kingston'. "
+            "The closest match from the MyLogan address search is used."
+        ),
+    },
+}
+
+HEADERS = {
+    "accept": "application/json, text/javascript, */*; q=0.01",
+    "referer": URL + "/MyLogan",
+    "user-agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/124.0.0.0 Safari/537.36"
+    ),
+    "x-requested-with": "XMLHttpRequest",
+}
+
+ICON_MAP = {
+    "general waste": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+    "green waste": Icons.ORGANIC,
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.logan.qld.gov.au",
+    argument_name="property_location",
+    max_results=1,
+    headers=HEADERS,
+    use_curl_cffi=True,
+    date_format="%A %d %B %Y",
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(self, property_location: str):
+        self._property_location = " ".join(property_location.split())
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def fetch(self) -> list[Collection]:
+        return self._client.fetch(address=self._property_location)

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

@@ -0,0 +1,17 @@
+TITLE = "Landkreis Schwäbisch Hall (Broken)"
+DESCRIPTION = "Broken Do not use anymore. Use app_abfallplus_de instead."
+URL = "https://www.lrasha.de"
+
+TEST_CASES = {"BROKEN": {"location": "BROKEN"}}
+
+
+class Source:
+    def __init__(self, location):
+        raise Exception(
+            "This source is no longer supported. Use app_abfallplus_de instead."
+        )
+
+    def fetch(self):
+        raise Exception(
+            "This source is no longer supported. Use app_abfallplus_de instead."
+        )

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

@@ -0,0 +1,56 @@
+import logging
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "Landskrona - Svalövs Renhållning"
+DESCRIPTION = "Source for LSR waste collection."
+COUNTRY = "se"
+URL = "https://www.lsr.nu"
+TEST_CASES = {
+    "Home": {"street_address": "Saxtorpsvägen 115, Annelöv"},
+    "Polisen": {"street_address": "Herrevadsgatan 11, Svalöv"},
+}
+
+# {
+#   "containerId": "12C",
+#   "date": "2024-01-03T00:00:00",
+#   "title": "Hämtning av restavfall (kärl 370 liter)",
+#   "typeOfWaste": "REST",
+#   "typeOfWasteDescription": "Restavfall"
+# },
+# {
+#   "containerId": "13B",
+#   "date": "2024-01-03T00:00:00",
+#   "title": "Hämtning av matavfall (kärl 140 liter)",
+#   "typeOfWaste": "MAT",
+#   "typeOfWasteDescription": "Matavfall"
+# }
+
+
+class Source:
+    def __init__(self, street_address):
+        self._street_address = street_address
+
+    def fetch(self):
+        response = requests.get(
+            "https://minasidor.lsr.nu/api/api/external/schedule/"
+            + self._street_address,
+        )
+
+        data = response.json()
+
+        entries = []
+        for item in data:
+            waste_type = item["typeOfWasteDescription"]
+            icon = "mdi:trash-can"
+            if waste_type == "Trädgårdsavfall":
+                icon = "mdi:leaf"
+            next_pickup = item["date"]
+            next_pickup_date = datetime.fromisoformat(next_pickup).date()
+            entries.append(Collection(date=next_pickup_date, t=waste_type, icon=icon))
+
+        return entries

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

@@ -0,0 +1,72 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Luleå"
+DESCRIPTION = "Source for Luleå."
+URL = "https://www.lumire.se/"
+TEST_CASES = {
+    "Ringgatan 20": {"address": "Ringgatan 20"},
+    "Gårdsvägen 11": {"address": "GÅRDSVÄGEN 11, LULEÅ"},
+    "Ymergatan 5": {"address": "Ymergatan 5"},
+}
+
+
+ICON_MAP = {
+    "Restavfall": Icons.GENERAL_WASTE,
+    "Matavfall": Icons.BIO_KITCHEN,
+    "Porslin": Icons.BIO_KITCHEN,
+    "Returpapper": Icons.PAPER,
+    "Pappersförpackningar": Icons.PAPER,
+    "Plastförpackningar": Icons.RECYCLING,
+    "Metallförpackningar": Icons.METAL,
+    "Färgade": Icons.GLASS,
+    "Ofärgade": Icons.GLASS,
+    "Ljuskällor": Icons.ELECTRONICS,
+    "Småbatterier": Icons.BATTERY,
+}
+
+API_URL = "https://lumire.se/api/waste-pickup"
+HEADERS = {"User-Agent": "Mozilla/5.0"}
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address: str = address
+
+    def fetch(self) -> list[Collection]:
+        # Först ber man snällt om ens buildingId hos våra vänner på Lumire
+        r = requests.get(API_URL, params={"q": self._address}, headers=HEADERS)
+        r.raise_for_status()
+        search_results = r.json().get("addresses", [])
+
+        if not search_results:
+            raise ValueError(f"Address '{self._address}' not found")
+
+        building_id = search_results[0].get("buildingId")
+
+        # mha buildingId får man sitt faktiska schema
+        r = requests.get(f"{API_URL}/{building_id}", headers=HEADERS)
+        r.raise_for_status()
+        pickup_data = r.json().get("data", [])
+
+        entries = []
+        for item in pickup_data:
+            date_str = item.get("nextPickup")
+            waste_type = item.get("fee", {}).get("waste_type") or item.get(
+                "description", ""
+            )
+
+            if date_str:
+                date_ = datetime.strptime(date_str, "%Y-%m-%d").date()
+
+                icon = None
+                for key, val in ICON_MAP.items():
+                    if key.lower() in waste_type.lower():
+                        icon = val
+                        break
+
+                entries.append(Collection(date_, waste_type, icon))
+
+        return entries

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

@@ -0,0 +1,71 @@
+import json
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Lund Waste Collection"
+DESCRIPTION = "Source for Lund waste collection services, Sweden."
+URL = "https://eservice431601.lund.se"
+TEST_CASES = {
+    "Lokföraregatan 7": {"street_address": "Lokföraregatan 7, LUND (19120)"},
+    "Annedalsvägen 2 B": {"street_address": "Annedalsvägen 2 B, LUND (39037)"},
+}
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+
+ICON_MAP = {
+    "Restavfall": Icons.GENERAL_WASTE,
+    "Plastförpacknin": Icons.RECYCLING,
+    "Tidningar": Icons.NEWSPAPER,
+    "Metallförpackni": Icons.METAL,
+    "Matavfall": Icons.BIO_KITCHEN,
+    "Ofärgat Glas": Icons.GLASS,
+    "Färgat Glas": Icons.GLASS,
+}
+
+
+class Source:
+    def __init__(self, street_address):
+        self._street_address = street_address
+
+    def fetch(self):
+        s = requests.Session()
+
+        # Search for the address ID
+        search_payload = {"searchText": self._street_address.split("(")[0].strip()}
+        search_response = s.post(
+            "https://eservice431601.lund.se/Lund/FutureWeb/SimpleWastePickup/SearchAdress",
+            json=search_payload,
+            headers=HEADERS,
+        )
+        search_data = json.loads(search_response.text)
+
+        # Check if the search was successful
+        if not search_data.get("Succeeded", False):
+            raise ValueError(f"Search for address failed for {self._street_address}.")
+
+        address_id = search_data["Buildings"][0] if search_data["Buildings"] else None
+        if not address_id:
+            raise ValueError(f"Failed to get address ID for {self._street_address}.")
+
+        # Retrieve waste collection schedule
+        schedule_url = f"https://eservice431601.lund.se/Lund/FutureWeb/SimpleWastePickup/GetWastePickupSchedule?address={address_id}"
+        schedule_response = s.get(schedule_url, headers=HEADERS)
+        schedule_data = json.loads(schedule_response.text)
+
+        entries = []
+        for service in schedule_data.get("RhServices", []):
+            waste_type = service.get("WasteType", "")
+
+            next_pickup = service.get("NextWastePickup", "")
+            next_pickup_date = datetime.fromisoformat(next_pickup).date()
+
+            entries.append(
+                Collection(
+                    date=next_pickup_date, t=waste_type, icon=ICON_MAP.get(waste_type)
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,191 @@
+import csv
+import logging
+from datetime import datetime
+
+import requests
+
+from ..collection import Collection
+from ..exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequiredWithSuggestions,
+)
+from ..icons import Icons
+
+TITLE = "Luxembourg"
+DESCRIPTION = "Source for Luxembourg waste collection using data.public.lu"
+URL = "https://data.public.lu"
+COUNTRY = "lu"
+
+_LOGGER = logging.getLogger(__name__)
+
+CSV_URL = "https://data.public.lu/fr/datasets/r/c3805ec5-7836-49a4-9983-effaf81910d0"
+
+_ALL_STREETS = "Toutes les rues"
+
+ICON_MAP = {
+    "Biodéchets": Icons.BIO_KITCHEN,
+    "Conteneur pour déchets ménagers": Icons.GENERAL_WASTE,
+    "Déchets de verdure": Icons.ORGANIC,
+    "Déchets d'équipements électriques et électroniques": Icons.ELECTRONICS,
+    "Déchets d’équipements électriques et électroniques": Icons.ELECTRONICS,
+    "Déchets encombrants": Icons.BULKY,
+    "Déchets encombrants en vrac": Icons.BULKY,
+    "Déchets ménagers en mélange": Icons.GENERAL_WASTE,
+    "Déchets recyclables": Icons.RECYCLING,
+    "Ferraille": Icons.METAL,
+    "Papier/Carton": Icons.PAPER,
+    "Papier/Carton (commerces)": Icons.PAPER,
+    "Papier/Carton – 40L": Icons.PAPER,
+    "PMC": Icons.PLASTIC_PACKAGING,
+    "SuperDrecksKëscht": Icons.HAZARDOUS,
+    "Valorlux": Icons.RECYCLING,
+    "Verre": Icons.GLASS,
+    "Verre (commerces)": Icons.GLASS,
+    "Verre – 40L": Icons.GLASS,
+    "Vieux bois": Icons.CHRISTMAS_TREE,
+    "Vieux vêtements": Icons.TEXTILE,
+}
+
+TEST_CASES = {
+    "Beaufort": {"commune": "Beaufort"},
+    "Reisdorf": {"commune": "Reisdorf"},
+    "Bech - specific street": {
+        "commune": "Bech",
+        "localite": "Bech",
+        "rue": "Am Biirk",
+    },
+    "Pétange - Rodange": {
+        "commune": "Pétange",
+        "localite": "Rodange",
+        "rue": "Rue Willy Huberty",
+    },
+}
+
+
+def _fetch_rows() -> list[dict]:
+    """Fetch and parse the CSV."""
+    response = requests.get(CSV_URL, timeout=30)
+    response.raise_for_status()
+    content = response.content.decode("utf-8-sig")
+    reader = csv.DictReader(content.splitlines(), delimiter=";", quotechar='"')
+    return list(reader)
+
+
+class Source:
+    def __init__(
+        self,
+        commune: str,
+        localite: str | None = None,
+        rue: str | None = None,
+    ):
+        self._commune = commune.strip()
+        self._localite = localite.strip() if localite else None
+        self._rue = rue.strip() if rue else None
+
+    def fetch(self) -> list[Collection]:
+        rows = _fetch_rows()
+
+        # --- Validate commune ---
+        all_communes = sorted(
+            {r.get("Commune", "").strip() for r in rows if r.get("Commune", "").strip()}
+        )
+        if self._commune not in all_communes:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "commune", self._commune, all_communes
+            )
+
+        commune_rows = [
+            r for r in rows if r.get("Commune", "").strip() == self._commune
+        ]
+
+        # --- Validate / resolve localite ---
+        all_localites = sorted(
+            {
+                r.get("Localité", "").strip()
+                for r in commune_rows
+                if r.get("Localité", "").strip()
+            }
+        )
+
+        if all_localites:
+            # This commune has per-locality rows
+            if self._localite is None:
+                raise SourceArgumentRequiredWithSuggestions(
+                    "localite",
+                    "required to narrow down the collection schedule",
+                    all_localites,
+                )
+            if self._localite not in all_localites:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "localite", self._localite, all_localites
+                )
+
+            # Include rows matching the locality AND rows with no locality (commune-wide)
+            localite_rows = [
+                r
+                for r in commune_rows
+                if r.get("Localité", "").strip() in (self._localite, "")
+            ]
+        else:
+            # Commune has no locality breakdown — use all commune rows
+            localite_rows = commune_rows
+
+        # --- Validate / resolve rue ---
+        all_rues = sorted(
+            {
+                r.get("Rue", "").strip()
+                for r in localite_rows
+                if r.get("Rue", "").strip() and r.get("Rue", "").strip() != _ALL_STREETS
+            }
+        )
+
+        if all_rues:
+            # Has per-street rows (beyond "Toutes les rues")
+            if self._rue is None:
+                raise SourceArgumentRequiredWithSuggestions(
+                    "rue",
+                    "required to narrow down the collection schedule",
+                    all_rues,
+                )
+            if self._rue not in all_rues:
+                raise SourceArgumentNotFoundWithSuggestions("rue", self._rue, all_rues)
+
+            active_rows = [
+                r
+                for r in localite_rows
+                if r.get("Rue", "").strip() in (self._rue, _ALL_STREETS)
+            ]
+        else:
+            active_rows = localite_rows
+
+        # --- Build collections (deduplicated by date+type) ---
+        entries = []
+        seen: set[tuple] = set()
+
+        for row in active_rows:
+            date_str = row.get("Date", "").strip()
+            waste_type = row.get("Type de collecte", "").strip()
+
+            if not date_str or not waste_type:
+                continue
+
+            try:
+                pickup_date = datetime.strptime(date_str, "%d/%m/%Y").date()
+            except ValueError:
+                _LOGGER.warning("Unrecognised date format: %s", date_str)
+                continue
+
+            key = (pickup_date, waste_type)
+            if key in seen:
+                continue
+            seen.add(key)
+
+            entries.append(
+                Collection(
+                    date=pickup_date,
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type, "mdi:trash-can"),
+                )
+            )
+
+        return entries