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

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

@@ -0,0 +1,209 @@
+import re
+from datetime import date, datetime, timedelta, timezone
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+    SourceArgumentRequiredWithSuggestions,
+)
+
+TITLE = "Aneby Miljö & Vatten"
+DESCRIPTION = "Source for Aneby Miljö & Vatten waste collection schedules."
+URL = "https://aen.minasidor.info/"
+COUNTRY = "se"
+TEST_CASES = {
+    "Nassjo": {
+        "email": "!secret aen_minasidor_se_email",
+        "password": "!secret aen_minasidor_se_password",
+        "address": "!secret aen_minasidor_se_address",
+    },
+}
+
+BASE_URL = "https://aen.minasidor.info"
+CSRF_URL = f"{BASE_URL}/api/auth/csrf"
+LOGIN_URL = f"{BASE_URL}/api/auth/callback/email"
+SESSION_URL = f"{BASE_URL}/api/auth/session"
+PICKUPS_URL = (
+    "https://fpservice.bmsystem.se/1802Nassjo/"
+    "CustomerDataProvider.svc/GetPickupAddresses"
+)
+API_URL = (
+    "https://fpservice.bmsystem.se/1802Nassjo/"
+    "CustomerDataProvider.svc/GetCalendarAndHistory"
+)
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "email": "Email address",
+        "password": "Password",
+        "address": "Address",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "email": "Email address used to log in to AEN Mina Sidor.",
+        "password": "Password used to log in to AEN Mina Sidor.",
+        "address": "Address to use when the account has more than one property.",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Use the email address and password for AEN Mina Sidor. The source "
+    "automatically finds the collection point. If your account has multiple "
+    "properties, select the address shown in the configuration flow.",
+}
+
+ICON_MAP = {
+    "Rest/Mat": Icons.GENERAL_WASTE,
+    "Papper/Plast": Icons.RECYCLING,
+}
+
+_DATE_PATTERN = re.compile(r"^/Date\((-?\d+)([+-]\d{4})?\)/$")
+
+
+class Source:
+    def __init__(self, email: str, password: str, address: str | None = None):
+        self._email = (email or "").strip()
+        if not self._email:
+            raise SourceArgumentRequired("email", "An email address is required.")
+        if not password:
+            raise SourceArgumentRequired("password", "A password is required.")
+        self._password = password
+        self._address = address.strip() if address else None
+
+    def fetch(self) -> list[Collection]:
+        today = date.today()
+        access_token = self._get_access_token()
+        pickup_ids = self._get_pickup_ids(access_token)
+
+        entries = []
+        for pickup_id in pickup_ids:
+            response = requests.get(
+                API_URL,
+                params={
+                    "dateStart": today.isoformat(),
+                    "dateEnd": (today + timedelta(days=365)).isoformat(),
+                    "pickupId": pickup_id,
+                },
+                headers={"Authorization": f"Bearer {access_token}"},
+                timeout=30,
+            )
+            response.raise_for_status()
+
+            data = response.json().get("d") or {}
+            for job in data.get("Jobs", []):
+                calendar = job.get("Calendar") or {}
+                execution_date = _parse_date(calendar.get("ExecutionDate", ""))
+                if execution_date is None or execution_date < today:
+                    continue
+
+                waste_type = calendar.get("ContentType", "").strip()
+                container_type = calendar.get("ContainerType", "").strip()
+                if not waste_type:
+                    continue
+
+                entries.append(
+                    Collection(
+                        date=execution_date,
+                        t=f"{container_type}: {waste_type}"
+                        if container_type
+                        else waste_type,
+                        icon=ICON_MAP.get(waste_type, Icons.GENERAL_WASTE),
+                    )
+                )
+
+        return entries
+
+    def _get_pickup_ids(self, access_token: str) -> list[str]:
+        response = requests.get(
+            PICKUPS_URL,
+            headers={"Authorization": f"Bearer {access_token}"},
+            timeout=30,
+        )
+        response.raise_for_status()
+
+        data = response.json().get("d") or {}
+        pickup_addresses = data.get("PickupAddresses", [])
+        addresses: dict[str, list[str]] = {}
+        for pickup in pickup_addresses:
+            address = pickup.get("Address", "").strip()
+            pickup_id = pickup.get("PickupId", "").strip()
+            if address and pickup_id:
+                addresses.setdefault(address, []).append(pickup_id)
+
+        if not addresses:
+            raise SourceArgumentNotFound(
+                "address",
+                self._address or "",
+                "no collection points were returned",
+            )
+
+        if self._address is None:
+            if len(addresses) == 1:
+                return next(iter(addresses.values()))
+            raise SourceArgumentRequiredWithSuggestions(
+                "address",
+                "Select the property for which to retrieve the schedule.",
+                sorted(addresses),
+            )
+
+        if self._address not in addresses:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address", self._address, sorted(addresses)
+            )
+        return addresses[self._address]
+
+    def _get_access_token(self) -> str:
+        session = requests.Session()
+
+        response = session.get(CSRF_URL, timeout=30)
+        response.raise_for_status()
+        csrf_token = response.json().get("csrfToken")
+        if not csrf_token:
+            raise SourceArgumentExceptionMultiple(
+                ("email", "password"), "Could not initialize the AEN login."
+            )
+
+        response = session.post(
+            LOGIN_URL,
+            data={
+                "id": self._email,
+                "password": self._password,
+                "csrfToken": csrf_token,
+                "callbackUrl": BASE_URL,
+                "json": "true",
+            },
+            timeout=30,
+        )
+        response.raise_for_status()
+
+        response = session.get(SESSION_URL, timeout=30)
+        response.raise_for_status()
+        access_token = response.json().get("accessToken")
+        if not access_token:
+            raise SourceArgumentExceptionMultiple(
+                ("email", "password"), "Login failed: invalid credentials."
+            )
+        return access_token
+
+
+def _parse_date(value: str) -> date | None:
+    match = _DATE_PATTERN.match(value)
+    if match is None:
+        return None
+
+    milliseconds = int(match.group(1))
+    offset = match.group(2)
+    if offset is None:
+        return datetime.fromtimestamp(milliseconds / 1000, timezone.utc).date()
+
+    sign = 1 if offset.startswith("+") else -1
+    hours = int(offset[1:3])
+    minutes = int(offset[3:5])
+    tz = timezone(sign * timedelta(hours=hours, minutes=minutes))
+    return datetime.fromtimestamp(milliseconds / 1000, tz).date()

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

@@ -0,0 +1,373 @@
+import logging
+import random
+import re
+from datetime import date, datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Affaldonline"
+DESCRIPTION = "Affaldonline"
+URL = "https://affaldonline.dk"
+API_URL = "https://www.affaldonline.dk/kalender/{municipality}/showInfo.php"
+
+_LOGGER = logging.getLogger("waste_collection_schedule.affaldonline_dk")
+
+PARSERS = {
+    "default": {
+        "description": "Næste tømningsdag: DD den D MMMMM YYYY (waste_type_1, waste_type_2)",
+        "regex": r"(\d{1,2})\. (\w+) (\d{4})",
+        "enabled": True,
+    },
+    "silkeborg": {
+        "description": "A table with dates in the format DD-MM and waste types",
+        "regex": r"(\d{2})-(\d{2})",
+        "enabled": True,
+    },
+    "favrskov": {
+        "description": "Blåmejsevej 1 (8382 Hinnerup) with multiple waste types",
+        "regex": r"Næste tømningsdag: (\w+) den (\d{1,2})\. (\w+) (\d{4})",
+        "enabled": True,
+    },
+    "pdf": {
+        "description": "Not yet supported parser for PDF files",
+        "regex": None,
+        "enabled": False,
+    },
+}
+
+AFFALDONLINE_MUNICIPALITIES = {
+    "aeroe": {
+        "title": "Ærø Kommune",
+        "url": "https://www.aeroekommune.dk/",
+        "parser": "default",
+        "values": "Nørregade|1||||5970|Ærøskøbing|1228262|448776|0",
+    },
+    "assens": {
+        "title": "Assens Forsyning",
+        "url": "https://www.assensforsyning.dk/",
+        "parser": "default",
+        "values": "Nørregade|1||||5610|Assens|10894|430000|0",
+    },
+    "favrskov": {
+        "title": "Favrskov Forsyning",
+        "url": "https://www.favrskovforsyning.dk",
+        "parser": "favrskov",
+        "values": "Nørregade|1||||8382|Hinnerup|6443|108156|0",
+    },
+    "fanoe": {
+        "title": "Fanø Kommune",
+        "url": "https://fanoe.dk/",
+        "parser": "pdf",
+        "values": "Nørre Klit|5||||6720|Fanø|2582|1747246|0",
+    },
+    "ffv": {
+        "title": "Faaborg Forsynings Virksomhed",
+        "url": "https://www.ffv.dk/",
+        "parser": "pdf",
+        "values": "Marsk Billesvej|18||||5672|Broby|36193544|576846|0",
+    },
+    "fredericia": {
+        "title": "Fredericia Kommune Affald & Genbrug",
+        "url": "https://affaldgenbrug-fredericia.dk/",
+        "parser": "pdf",
+        "values": "Nørre Allé|5||||7000|Fredericia|11079971|1907927|0",
+    },
+    "langeland": {
+        "title": "Langeland Forsyning",
+        "url": "https://www.langeland-forsyning.dk/",
+        "parser": "default",
+        "values": "Nørregade|1||||5900|Rudkøbing|3535|383566|0",
+    },
+    "middelfart": {
+        "title": "Middelfart Kommune",
+        "url": "https://middelfart.dk/",
+        "parser": "default",
+        "values": "Nørregade|2||||5592|Ejby|11288085|6496420|0",
+    },
+    "nyborg": {
+        "title": "Nyborg Forsyning & Service A/S",
+        "url": "https://www.nfs.as/",
+        "parser": "pdf",
+        "values": "Nørregade|5||||5800|Nyborg|8896288|552542|0",
+    },
+    "rebild": {
+        "title": "Rebild Kommune",
+        "url": "https://rebild.dk/",
+        "parser": "default",
+        "values": "Nørregade|1||||9500|Hobro|4676913|1012588|0",
+    },
+    "silkeborg": {
+        "title": "Silkeborg Forsyning",
+        "url": "https://www.silkeborgforsyning.dk/",
+        "parser": "silkeborg",
+        "values": "Nørregade|5||||8620|Kjellerup|45814316|1291964|0",
+    },
+    "soroe": {
+        "title": "Sorø Kommune",
+        "url": "https://soroe.dk/",
+        "parser": "pdf",
+        "values": "Nørrevej|4| |||4180|Sorø|8569|8838|0|0",
+    },
+    "vejle": {
+        "title": "Vejle Kommune",
+        "url": "https://www.vejle.dk/",
+        "parser": "default",
+        "values": "Nørregade|69||||7100|Vejle|16285351|16285351|0",
+    },
+    "viborg": {
+        "title": "Revas (Viborg Kommune)",
+        "url": "https://www.revas.dk/",
+        "parser": "default",
+        "values": "Hjultorvet|1||||8800|Viborg|8228245|8739|0",
+    },
+}
+
+EXTRA_INFO = [
+    {
+        "title": info["title"],
+        "url": info["url"],
+        "default_params": {"municipality": municipality},
+    }
+    for municipality, info in AFFALDONLINE_MUNICIPALITIES.items()
+    if info["parser"] != "pdf"
+]
+
+
+def select_test_cases(municipalities, mode="random_one_from_each_parser"):
+    test_cases = {}
+    parser_test_cases = {}
+
+    for name, info in municipalities.items():
+        parser = info["parser"]
+        if PARSERS[parser]["enabled"]:
+            if parser not in parser_test_cases:
+                parser_test_cases[parser] = []
+            parser_test_cases[parser].append((name, info))
+
+    if mode == "random_one_from_each_parser":
+        for _parser, cases in parser_test_cases.items():
+            selected_case = random.choice(cases)
+            test_cases[selected_case[0]] = {
+                "municipality": selected_case[0],
+                "values": selected_case[1]["values"],
+            }
+    elif mode == "first_from_each_parser":
+        for _parser, cases in parser_test_cases.items():
+            selected_case = cases[0]
+            test_cases[selected_case[0]] = {
+                "municipality": selected_case[0],
+                "values": selected_case[1]["values"],
+            }
+    elif mode == "random_one":
+        all_cases = [case for cases in parser_test_cases.values() for case in cases]
+        selected_case = random.choice(all_cases)
+        test_cases[selected_case[0]] = {
+            "municipality": selected_case[0],
+            "values": selected_case[1]["values"],
+        }
+    elif mode == "first_one":
+        first_parser = next(iter(parser_test_cases.keys()))
+        selected_case = parser_test_cases[first_parser][0]
+        test_cases[selected_case[0]] = {
+            "municipality": selected_case[0],
+            "values": selected_case[1]["values"],
+        }
+    elif mode == "all":
+        for _parser, cases in parser_test_cases.items():
+            for case in cases:
+                test_cases[case[0]] = {
+                    "municipality": case[0],
+                    "values": case[1]["values"],
+                }
+
+    return test_cases
+
+
+# Dynamically generate TEST_CASES from the AFFALDONLINE_MUNICIPALITIES dictionary
+TEST_CASES = select_test_cases(
+    AFFALDONLINE_MUNICIPALITIES, mode="first_from_each_parser"
+)
+
+DANISH_MONTHS = [
+    "januar",
+    "februar",
+    "marts",
+    "april",
+    "maj",
+    "juni",
+    "juli",
+    "august",
+    "september",
+    "oktober",
+    "november",
+    "december",
+]
+
+
+class Source:
+    def __init__(self, municipality: str, values: str):
+        _LOGGER.debug(
+            "Initializing Source with municipality=%s, values=%s", municipality, values
+        )
+        self._api_url = API_URL.format(municipality=municipality)
+        self._values = values
+        self._parser_type = AFFALDONLINE_MUNICIPALITIES.get(municipality, {}).get(
+            "parser"
+        )
+        if not self._parser_type:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "municipality", municipality, AFFALDONLINE_MUNICIPALITIES.keys()
+            )
+
+        parser = getattr(self, f"_parse_{self._parser_type}", None)
+        if parser is None:
+            raise ValueError(f"Parser method for {self._parser_type} not implemented")
+        if not callable(parser):
+            raise ValueError(f"Parser method for {self._parser_type} is not callable")
+
+        self._parser_method = parser
+
+    def fetch(self) -> list[Collection]:
+        _LOGGER.debug("Fetching data from %s", self._api_url)
+
+        entries: list[Collection] = []
+
+        post_data = {"values": self._values}
+
+        response = requests.post(self._api_url, data=post_data)
+        response.raise_for_status()
+
+        html_content = response.text
+        soup = BeautifulSoup(html_content, "html.parser")
+
+        entries.extend(self._parser_method(soup))
+
+        return entries
+
+    def _parse_default(self, soup: BeautifulSoup) -> list[Collection]:
+        entries: list[Collection] = []
+
+        next_pickup_info = soup.find_all(string=re.compile("Næste tømningsdag:"))
+        if not next_pickup_info:
+            raise ValueError(
+                "No waste schemes found. Please check the provided values."
+            )
+
+        for info in next_pickup_info:
+            text = info.strip()
+            match = re.search(r"(\d{1,2})\. (\w+) (\d{4})", text)
+            if match:
+                try:
+                    day = int(match.group(1))
+                    month_name = match.group(2)
+                    year = int(match.group(3))
+                    month_index = DANISH_MONTHS.index(month_name) + 1
+                    formatted_date = date(year, month_index, day)
+
+                    # Extract waste types from the text
+                    waste_type_search = re.search(r"\((.*?)\)", text)
+                    if waste_type_search is None:
+                        _LOGGER.warning("No waste type found in string: %s", text)
+                        continue
+                    waste_types_text = waste_type_search.group(1)
+
+                    waste_types = [
+                        waste_type.strip() for waste_type in waste_types_text.split(",")
+                    ]
+
+                    for waste_type in waste_types:
+                        entries.append(Collection(date=formatted_date, t=waste_type))
+                        _LOGGER.debug(
+                            "Added collection: date=%s, type=%s",
+                            formatted_date,
+                            waste_type,
+                        )
+                except ValueError as e:
+                    _LOGGER.error("Error parsing date: %s from string: %s", e, text)
+            else:
+                _LOGGER.warning("No valid date found in string: %s", text)
+
+        return entries
+
+    def _parse_silkeborg(self, soup: BeautifulSoup) -> list[Collection]:
+        entries: list[Collection] = []
+
+        table = soup.find("table")
+        if not table:
+            raise ValueError(
+                "No waste collection table found. Please check the provided values."
+            )
+
+        current_year = datetime.now().year
+        current_month = datetime.now().month
+
+        for row in table.find_all("tr"):
+            cells = row.find_all("td")
+            if len(cells) == 2:
+                # Extract date and waste type
+                date_str = cells[0].get_text(strip=True)
+                waste_types = cells[1].get_text(strip=True)
+
+                match = re.search(r"(\d{2})-(\d{2})", date_str)
+                if match:
+                    day = int(match.group(1))
+                    month = int(match.group(2))
+
+                    # Determine the year based on the current month
+                    collection_year = current_year
+                    if month < current_month:
+                        collection_year += 1
+
+                    collection_date = date(collection_year, month, day)
+
+                    for waste_type in waste_types.split(","):
+                        entries.append(
+                            Collection(date=collection_date, t=waste_type.strip())
+                        )
+                        _LOGGER.debug(
+                            "Added collection: date=%s, type=%s",
+                            collection_date,
+                            waste_type.strip(),
+                        )
+
+        return entries
+
+    def _parse_favrskov(self, soup: BeautifulSoup) -> list[Collection]:
+        entries: list[Collection] = []
+
+        strong_tags = soup.find_all("strong")
+        if not strong_tags:
+            raise ValueError(
+                "No waste schemes found. Please check the provided values."
+            )
+
+        for strong_tag in strong_tags:
+            waste_type = strong_tag.get_text(strip=True)
+            next_sibling = strong_tag.find_next_sibling(text=True)
+            if next_sibling and "Næste tømningsdag" in next_sibling:
+                match = re.search(r"(\d{1,2})\. (\w+) (\d{4})", next_sibling)
+                if match:
+                    try:
+                        day = int(match.group(1))
+                        month_name = match.group(2)
+                        year = int(match.group(3))
+                        month_index = DANISH_MONTHS.index(month_name) + 1
+                        formatted_date = date(year, month_index, day)
+
+                        entries.append(Collection(date=formatted_date, t=waste_type))
+                        _LOGGER.debug(
+                            "Added collection: date=%s, type=%s",
+                            formatted_date,
+                            waste_type,
+                        )
+                    except ValueError as e:
+                        _LOGGER.error(
+                            "Error parsing date: %s from string: %s", e, next_sibling
+                        )
+                else:
+                    _LOGGER.warning("No valid date found in string: %s", next_sibling)
+
+        return entries

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

@@ -0,0 +1,67 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Affärsverken"
+DESCRIPTION = "Source for Affärsverken."
+URL = "https://www.affarsverken.se/"
+
+TEST_CASES = {
+    "Albatrossvägen 5, Ramdala": {"address": "Albatrossvägen 5, Ramdala"},
+    "Amandas Väg 11, Sturkö": {"address": "Amandas Väg 11, Sturkö"},
+    "Uddabygd 107, Rödeby": {"address": "Uddabygd 107, Rödeby"},
+    "Zenitavägen 2, Hasslö": {"address": "Zenitavägen 2, Hasslö"},
+}
+
+ICON_MAP = {
+    "Restavfall": Icons.GENERAL_WASTE,
+    "Matavfall": Icons.BIO_KITCHEN,
+    "Trädgårdsavfall": Icons.GARDEN,
+}
+
+API_URL = "https://kundapi.affarsverken.se/api/v1/open-api/"
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address: str = address
+
+    def fetch(self):
+        args = {"address": self._address}
+
+        r = requests.post(f"{API_URL}login", params={"BrandName": "Affarsverken"})
+        r.raise_for_status()
+        headers = {"Authorization": "Bearer " + r.text}
+
+        r = requests.get(
+            f"{API_URL}waste/buildings/search", params=args, headers=headers
+        )
+        data = r.json()
+        building_query = data[0]["query"]
+
+        r = requests.get(f"{API_URL}waste/buildings/" + building_query, headers=headers)
+        r.raise_for_status()
+        services = r.json()["services"]
+
+        entries = []
+        for service in services:
+            if not service["nextPickup"]:
+                continue
+            date = datetime.datetime.strptime(service["nextPickup"], "%Y-%m-%d").date()
+            icon = ICON_MAP.get(service["title"])  # Collection icon
+            type = service["title"]
+
+            # add bin size to description
+            if "binSize" in service and "binSizeUnit" in service:
+                type += (
+                    ", "
+                    + str(service["binSize"]).replace(".0", "")
+                    + " "
+                    + str(service["binSizeUnit"])
+                )
+            type = type.strip()
+
+            entries.append(Collection(date=date, t=type, icon=icon))
+
+        return entries