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

package/python/vendor/waste_collection_schedule/service/uk_cloud9_apps.py

@@ -0,0 +1,414 @@
+import re
+from collections.abc import Sequence
+from datetime import date, datetime
+from typing import Any, cast
+
+from curl_cffi import requests
+from curl_cffi.const import CurlHttpVersion
+
+from waste_collection_schedule import Collection
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+API_DOMAINS = (
+    "https://apps.cloud9apps.com",
+    "https://apps.cloud9technologies.com",
+)
+API_BASE = "/citizenmobile/mobileapi"
+ADDRESSES_PATH = "/addresses"
+WASTE_PATH = "/wastecollections"
+REQUEST_TIMEOUT = 30
+
+BASIC_TOKEN = "Y2xvdWQ5OmlkQmNWNGJvcjU="
+BASE_HEADERS = {
+    "Authorization": f"Basic {BASIC_TOKEN}",
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+    "x-api-version": "2",
+}
+
+POSTCODE_PATTERN = re.compile(r"([A-Z]{1,2}\d[A-Z\d]?)\s*(\d[A-Z]{2})", re.IGNORECASE)
+ISO_DATE_PATTERN = re.compile(r"\d{4}-\d{2}-\d{2}")
+
+ADDRESS_FIELDS = (
+    "fullAddress",
+    "singleLineAddress",
+    "address",
+    "addressLine1",
+    "addressLine2",
+    "addressLine3",
+    "town",
+    "buildingName",
+    "buildingNumber",
+    "propertyNumber",
+    "street",
+    "postcode",
+)
+
+Address = dict[str, Any]
+JSONDict = dict[str, Any]
+
+
+def normalise_postcode(text: str | None) -> str | None:
+    if not text:
+        return None
+    match = POSTCODE_PATTERN.search(text)
+    if not match:
+        return None
+    return f"{match.group(1).upper()} {match.group(2).upper()}"
+
+
+def _address_to_string(address: Address) -> str:
+    return " ".join(
+        str(value)
+        for key in ADDRESS_FIELDS
+        for value in [address.get(key)]
+        if value not in (None, "")
+    ).strip()
+
+
+def _clean_type_name(name: str) -> str:
+    cleaned = name.strip()
+    if cleaned.lower().endswith("collection"):
+        cleaned = cleaned[: -len("collection")].strip()
+    if cleaned.lower().endswith("bins"):
+        cleaned = cleaned[: -len("bins")].strip()
+    elif cleaned.lower().endswith("bin"):
+        cleaned = cleaned[: -len("bin")].strip()
+    return cleaned or name
+
+
+def _parse_date_string(value: Any) -> date | None:
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value.date()
+    if not isinstance(value, str):
+        return None
+    candidate = value.strip()
+    if not candidate:
+        return None
+    iso_candidate = candidate
+    if iso_candidate.endswith("Z"):
+        iso_candidate = iso_candidate[:-1] + "+00:00"
+    try:
+        return datetime.fromisoformat(iso_candidate).date()
+    except ValueError:
+        pass
+    iso_match = ISO_DATE_PATTERN.search(candidate)
+    if iso_match:
+        try:
+            return datetime.strptime(iso_match.group(), "%Y-%m-%d").date()
+        except ValueError:
+            pass
+    for fmt in ("%d/%m/%Y", "%d-%m-%Y"):
+        try:
+            return datetime.strptime(candidate, fmt).date()
+        except ValueError:
+            continue
+    return None
+
+
+def _extract_dates(details: dict[str, Any]) -> list[date]:
+    values: list[Any] = [
+        details.get(key)
+        for key in ("collectionDate", "nextCollectionDate", "nextCollection")
+    ]
+    values.extend(details.get("collectionDates") or [])
+    values.extend(
+        (
+            (
+                entry.get("collectionDate")
+                or entry.get("nextCollectionDate")
+                or entry.get("date")
+            )
+            if isinstance(entry, dict)
+            else entry
+        )
+        for entry in details.get("futureCollections") or []
+    )
+    next_collection = cast(dict[str, Any], details.get("nextCollection") or {})
+    values.append(
+        next_collection.get("collectionDate")
+        or next_collection.get("nextCollectionDate")
+        or next_collection.get("date")
+    )
+
+    return sorted(
+        {parsed for parsed in map(_parse_date_string, values) if parsed is not None}
+    )
+
+
+def _collection_items(
+    collection_data: JSONDict,
+) -> list[tuple[str, dict[str, Any]]]:
+    collections_section = cast(
+        dict[str, dict[str, Any]] | None, collection_data.get("collections")
+    )
+    if collections_section:
+        return list(collections_section.items())
+    items: list[tuple[str, dict[str, Any]]] = []
+    for key, value in collection_data.items():
+        if not key.lower().endswith("collectiondetails"):
+            continue
+        if isinstance(value, list):
+            for idx, entry in enumerate(value, start=1):
+                if entry:
+                    items.append((f"{key}_{idx}", cast(dict[str, Any], entry)))
+        elif value:
+            items.append((key, cast(dict[str, Any], value)))
+    return items
+
+
+class Cloud9Client:
+    def __init__(
+        self,
+        authority: str,
+        icon_keywords: dict[str, str] | None = None,
+        api_domains: Sequence[str] | None = None,
+    ):
+        self._authority = authority
+        self._icon_keywords: dict[str, str] = icon_keywords or {}
+        configured_domains = API_DOMAINS if api_domains is None else api_domains
+        self._base_urls = [
+            f"{domain.rstrip('/')}/{authority}{API_BASE}"
+            for domain in configured_domains
+            if domain and domain.strip()
+        ]
+        if not self._base_urls:
+            raise ValueError("At least one API domain must be configured.")
+        # The Cloud9 API is fronted by an AWS ELB that sometimes echoes
+        # HTTP/1.1-only response headers (e.g. "keep-alive: timeout=5") on
+        # an HTTP/2 connection. This violates RFC 7540 8.1.2.2 and causes
+        # curl_cffi/nghttp2 to abort with CurlError 92 ("Invalid HTTP
+        # header field was received"). Forcing HTTP/1.1 avoids the strict
+        # HTTP/2 header validation and lets the request succeed.
+        self._session = requests.Session(
+            impersonate="chrome", http_version=CurlHttpVersion.V1_1
+        )
+        self._session.headers.update(BASE_HEADERS)
+
+    def _request_json(
+        self, path: str, params: dict[str, str] | None = None
+    ) -> JSONDict:
+        last_error: Exception | None = None
+        for base_url in self._base_urls:
+            try:
+                response = self._session.get(
+                    f"{base_url}{path}",
+                    params=params,
+                    timeout=REQUEST_TIMEOUT,
+                )
+                response.raise_for_status()
+                return cast(JSONDict, response.json())
+            except (
+                requests.exceptions.CertificateVerifyError,
+                requests.exceptions.ConnectionError,
+                requests.exceptions.DNSError,
+                requests.exceptions.SSLError,
+                requests.exceptions.Timeout,
+            ) as err:
+                last_error = err
+        assert last_error is not None
+        raise last_error
+
+    def _resolve_icon(self, label: str) -> str | None:
+        lowered = label.lower()
+        for keyword, icon in self._icon_keywords.items():
+            if keyword in lowered:
+                return icon
+        return None
+
+    def _build_collections(self, payload: JSONDict) -> list[Collection]:
+        collection_data = cast(
+            JSONDict,
+            payload.get("wasteCollectionDates")
+            or payload.get("WasteCollectionDates")
+            or payload,
+        )
+
+        entries: list[Collection] = []
+        seen: set[tuple[date, str]] = set()
+
+        for key, details in _collection_items(collection_data):
+            if not details:
+                continue
+            raw_label = (
+                details.get("containerDescription")
+                or details.get("containerName")
+                or details.get("collectionType")
+                or key
+            )
+            if not isinstance(raw_label, str):
+                raw_label = str(raw_label)
+            label = _clean_type_name(raw_label)
+            icon = self._resolve_icon(label)
+            for collection_date in _extract_dates(details):
+                identifier = (collection_date, label)
+                if identifier in seen:
+                    continue
+                seen.add(identifier)
+                entries.append(Collection(date=collection_date, t=label, icon=icon))
+
+        return entries
+
+    def _fetch_waste_json(self, uprn: str) -> JSONDict:
+        return self._request_json(f"{WASTE_PATH}/{uprn}")
+
+    def fetch_by_uprn(self, uprn: str) -> list[Collection]:
+        payload = self._fetch_waste_json(uprn)
+        entries = self._build_collections(payload)
+        entries.sort(key=lambda item: item.date)
+        return entries
+
+    def fetch_by_address(
+        self,
+        postcode: str | None,
+        address_string: str,
+        address_name_number: str | None = None,
+        address_street: str | None = None,
+        street_town: str | None = None,
+        argument_name: str = "address_postcode",
+    ) -> list[Collection]:
+        normalised = normalise_postcode(postcode)
+
+        addresses = self._lookup_addresses(
+            postcode=postcode,
+            normalised_postcode=normalised,
+            address_name_number=address_name_number,
+            address_street=address_street,
+            address_string=address_string,
+        )
+        selected = self._select_address(
+            addresses,
+            address_string=address_string,
+            normalised_postcode=normalised,
+            address_name_number=address_name_number,
+            address_street=address_street,
+            street_town=street_town,
+            argument_name=argument_name,
+        )
+        uprn = selected.get("uprn")
+        if not uprn:
+            raise ValueError("Selected address does not expose a UPRN.")
+
+        entries = self.fetch_by_uprn(uprn)
+        if not entries:
+            raise ValueError("No collection data returned for the selected address.")
+        return entries
+
+    def _lookup_addresses(
+        self,
+        postcode: str | None,
+        normalised_postcode: str | None,
+        address_name_number: str | None,
+        address_street: str | None,
+        address_string: str,
+    ) -> list[Address]:
+        address_line = " ".join(
+            part.strip()
+            for part in (address_name_number, address_street)
+            if isinstance(part, str) and part.strip()
+        )
+
+        seen: set[tuple[str, str]] = set()
+        attempts: list[tuple[str, str | None]] = [
+            ("postcode", normalised_postcode),
+            ("postcode", postcode),
+            ("address", address_string),
+            ("query", address_string),
+            ("address", address_line),
+            ("query", address_line),
+            ("query", address_street),
+        ]
+        for param, value in attempts:
+            cleaned = (value or "").strip()
+            if not cleaned:
+                continue
+            key = (param, cleaned.lower())
+            if key in seen:
+                continue
+            seen.add(key)
+            payload_json = self._request_json(
+                ADDRESSES_PATH,
+                params={param: cleaned},
+            )
+            addresses_data = cast(list[Address] | None, payload_json.get("addresses"))
+            if addresses_data:
+                return [cast(Address, a) for a in addresses_data]
+
+        raise ValueError("No matching addresses were returned by the API.")
+
+    def _select_address(
+        self,
+        addresses: Sequence[Address],
+        address_string: str,
+        normalised_postcode: str | None,
+        address_name_number: str | None,
+        address_street: str | None,
+        street_town: str | None,
+        argument_name: str,
+    ) -> Address:
+        if not addresses:
+            raise ValueError("Address lookup returned no results.")
+
+        query_lower = address_string.lower() if address_string else ""
+        postcode_lower = normalised_postcode.lower() if normalised_postcode else None
+
+        scored: list[tuple[int, Address]] = []
+        for address in addresses:
+            full = _address_to_string(address)
+            lowered = full.lower()
+            score = 0
+
+            candidate_postcode = normalise_postcode(address.get("postcode"))
+            if (
+                postcode_lower
+                and candidate_postcode
+                and candidate_postcode.lower() == postcode_lower
+            ):
+                score += 100
+            elif postcode_lower and postcode_lower in lowered:
+                score += 60
+
+            if address_street and address_street.lower() in lowered:
+                score += 30
+
+            if address_name_number:
+                number = str(address_name_number).strip().lower()
+                if re.search(rf"\b{re.escape(number)}\b", lowered):
+                    score += 25
+
+            if street_town and street_town.lower() in lowered:
+                score += 15
+
+            if query_lower and re.search(
+                rf"(?:^|\b){re.escape(query_lower)}(?:\b|$)", lowered
+            ):
+                score += 10
+
+            scored.append((score, address))
+
+        scored.sort(key=lambda x: x[0], reverse=True)
+        best_score = scored[0][0]
+
+        if best_score <= 0:
+            suggestions = [_address_to_string(a) for a in addresses]
+            raise SourceArgumentNotFoundWithSuggestions(
+                argument=argument_name,
+                value=address_string,
+                suggestions=suggestions,
+            )
+
+        top = [addr for s, addr in scored if s == best_score]
+        if len(top) > 1:
+            suggestions = [_address_to_string(a) for a in top]
+            raise SourceArgAmbiguousWithSuggestions(
+                argument=argument_name,
+                value=address_string,
+                suggestions=suggestions,
+            )
+
+        return top[0]

package/python/vendor/waste_collection_schedule/source/123abfallkalender_de.py

@@ -0,0 +1,197 @@
+import datetime
+
+import requests
+from icalendar import Calendar
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "123abfallkalender"
+DESCRIPTION = "Source script for 123abfallkalender.de (Ebsdorfergrund)"
+URL = "https://www.123abfallkalender.de/"
+
+EXTRA_INFO = [
+    {
+        "title": "Beltershausen",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/1-beltershausen",
+        "default_params": {
+            "district": "Beltershausen",
+        },
+    },
+    {
+        "title": "Dreihausen",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/2-dreihausen",
+        "default_params": {
+            "district": "Dreihausen",
+        },
+    },
+    {
+        "title": "Ebsdorf",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/3-ebsdorf",
+        "default_params": {
+            "district": "Ebsdorf",
+        },
+    },
+    {
+        "title": "Frauenberg",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/4-frauenberg",
+        "default_params": {
+            "district": "Frauenberg",
+        },
+    },
+    {
+        "title": "Hachborn",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/5-hachborn",
+        "default_params": {
+            "district": "Hachborn",
+        },
+    },
+    {
+        "title": "Heskem",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/6-heskem",
+        "default_params": {
+            "district": "Heskem",
+        },
+    },
+    {
+        "title": "Ilschhausen",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/7-ilschhausen",
+        "default_params": {
+            "district": "Ilschhausen",
+        },
+    },
+    {
+        "title": "Leidenhofen",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/8-leidenhofen",
+        "default_params": {
+            "district": "Leidenhofen",
+        },
+    },
+    {
+        "title": "Mölln",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/9-molln",
+        "default_params": {
+            "district": "Mölln",
+        },
+    },
+    {
+        "title": "Rauischholzhausen",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/10-rauischholzhausen",
+        "default_params": {
+            "district": "Rauischholzhausen",
+        },
+    },
+    {
+        "title": "Roßberg",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/11-rossberg",
+        "default_params": {
+            "district": "Roßberg",
+        },
+    },
+    {
+        "title": "Wermertshausen",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/12-wermertshausen",
+        "default_params": {
+            "district": "Wermertshausen",
+        },
+    },
+    {
+        "title": "Wittelsberg",
+        "url": "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund/13-wittelsberg",
+        "default_params": {
+            "district": "Wittelsberg",
+        },
+    },
+]
+
+SUPPORTED_DISTRICTS = {
+    "Beltershausen": "1-beltershausen",
+    "Dreihausen": "2-dreihausen",
+    "Ebsdorf": "3-ebsdorf",
+    "Frauenberg": "4-frauenberg",
+    "Hachborn": "5-hachborn",
+    "Heskem": "6-heskem",
+    "Ilschhausen": "7-ilschhausen",
+    "Leidenhofen": "8-leidenhofen",
+    "Mölln": "9-molln",
+    "Rauischholzhausen": "10-rauischholzhausen",
+    "Roßberg": "11-rossberg",
+    "Wermertshausen": "12-wermertshausen",
+    "Wittelsberg": "13-wittelsberg",
+}
+
+TEST_CASES = {
+    "Beltershausen": {"district": "Beltershausen"},
+    "Dreihausen": {"district": "Dreihausen"},
+    "Ebsdorf": {"district": "Ebsdorf"},
+    "Frauenberg": {"district": "Frauenberg"},
+    "Hachborn": {"district": "Hachborn"},
+    "Heskem": {"district": "Heskem"},
+    "Ilschhausen": {"district": "Ilschhausen"},
+    "Leidenhofen": {"district": "Leidenhofen"},
+    "Mölln": {"district": "Mölln"},
+    "Rauischholzhausen": {"district": "Rauischholzhausen"},
+    "Roßberg": {"district": "Roßberg"},
+    "Wermertshausen": {"district": "Wermertshausen"},
+    "Wittelsberg": {"district": "Wittelsberg"},
+}
+
+API_URL = "https://www.123abfallkalender.de/abfallkalender/rpecasvg-ebsdorfergrund"
+ICON_MAP = {
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Biomüll": Icons.BIO_KITCHEN,
+    "Altpapier": Icons.PAPER,
+    "Gelbe Tonne": Icons.PLASTIC_PACKAGING,
+    "MR Sondermüll": Icons.HAZARDOUS,
+    "EBS Sondermüll": Icons.HAZARDOUS,
+    "Praxis GmbH": Icons.HAZARDOUS,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Select your district from the list.",
+    "de": "Wählen Sie Ihren Ortsteil aus der Liste.",
+}
+
+PARAM_DESCRIPTIONS = {"en": {"district": "District"}, "de": {"district": "Ortsteil"}}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "district": "District",
+    },
+    "de": {
+        "district": "Ortsteil",
+    },
+}
+
+
+class Source:
+    def __init__(self, district: str):
+        if district not in SUPPORTED_DISTRICTS:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "district", district, list(SUPPORTED_DISTRICTS.keys())
+            )
+        self._slug = SUPPORTED_DISTRICTS[district]
+
+    def fetch(self) -> list[Collection]:
+        url = f"{API_URL}/{self._slug}.ics?alert=never"
+
+        r = requests.get(url, timeout=30)
+        r.raise_for_status()
+        cal = Calendar.from_ical(r.content)
+
+        entries = []
+
+        for event in cal.walk("VEVENT"):
+            summary = str(event.get("SUMMARY", "Unbekannt"))
+            date = event.get("DTSTART").dt
+            if isinstance(date, datetime.datetime):
+                date = date.date()
+            entries.append(
+                Collection(
+                    date=date, t=summary, icon=ICON_MAP.get(summary, "mdi:trash-can")
+                )
+            )
+
+        if not entries:
+            raise Exception(f"No entries for district {self._slug}")
+
+        return entries