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

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

@@ -0,0 +1,332 @@
+import json
+import re
+from datetime import datetime
+from urllib.parse import quote, urlencode
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentException
+
+TITLE = "Kauno švara"
+DESCRIPTION = 'Source for UAB "Kauno švara".'
+URL = "https://grafikai.svara.lt"
+TEST_CASES = {
+    "Demokratų g. 7, Kaunas": {
+        "region": "Kauno m. sav.",
+        "street": "Demokratų g.",
+        "house_number": "7",
+    },
+    "Alytaus g. 2, Išlaužo k., Išlaužo sen. Prienų r. sav.": {
+        "region": "Prienų r. sav.",
+        "street": "Alytaus g.",
+        "house_number": "2",
+        "district": "Išlaužo sen.",
+    },
+}
+
+ICON_MAP = {
+    "mišrių atliekų": Icons.GENERAL_WASTE,
+    "antrinių žaliavų (popierius/plastikas)": Icons.RECYCLING,
+    "antrinių žaliavų (stiklas)": Icons.GLASS,
+    "žaliųjų atliekų": Icons.ORGANIC,
+}
+
+# In late April 2026 grafikai.svara.lt was rewritten as a TanStack Start
+# (TSR) React app. The previous REST endpoints (/api/contracts,
+# /api/schedule) are gone — the new architecture proxies all data fetching
+# through a single server function: GET /_serverFn/<sha256> with a Seroval-
+# encoded payload of {data: {apiPath, tenantId}}.
+#
+# The function id is a sha256 baked into the JS bundle at build time and
+# changes every time upstream rebuilds. We scrape the live JS bundles to
+# find candidate ids and probe each against /schedule/getdistricts to pick
+# the data-fetching one — no hardcoded id, no manual updates needed when
+# upstream redeploys.
+_BASE_URL = "https://grafikai.svara.lt"
+_SERVER_FN_URL_TEMPLATE = _BASE_URL + "/_serverFn/{fn_id}"
+_TENANT_ID = 1
+
+
+def _seroval_encode_request(api_path: str, tenant_id: int = _TENANT_ID) -> str:
+    """Encode a {data: {apiPath, tenantId}} payload as Seroval JSON.
+
+    The full Seroval format is rich (handles cycles, refs, dates, regex, etc.),
+    but the request payload here is tiny and acyclic — just two scalars wrapped
+    in two object levels. We can hand-encode it directly without pulling in a
+    Seroval library.
+    """
+    return json.dumps(
+        {
+            "t": {
+                "t": 10,
+                "i": 0,
+                "p": {
+                    "k": ["data"],
+                    "v": [
+                        {
+                            "t": 10,
+                            "i": 1,
+                            "p": {
+                                "k": ["apiPath", "tenantId"],
+                                "v": [
+                                    {"t": 1, "s": api_path},
+                                    {"t": 2, "s": tenant_id},
+                                ],
+                            },
+                            "o": 0,
+                        }
+                    ],
+                },
+                "o": 0,
+            },
+            "f": 63,
+            "m": [],
+        },
+        separators=(",", ":"),
+    )
+
+
+def _seroval_decode(node):
+    """Decode a Seroval-encoded value tree to a Python value.
+
+    Handles the small subset of Seroval node types this API actually returns:
+        t=0 number, t=1 string, t=2 bigint (we coerce to int),
+        t=9 array, t=10/t=11 plain object.
+    """
+    if not isinstance(node, dict):
+        return node
+    t = node.get("t")
+    if t == 0:
+        return node.get("s")
+    if t == 1:
+        return node.get("s")
+    if t == 2:
+        return node.get("s")
+    if t == 9:
+        return [_seroval_decode(item) for item in node.get("a", [])]
+    if t in (10, 11):
+        p = node.get("p") or {}
+        keys = p.get("k", [])
+        vals = p.get("v", [])
+        return {k: _seroval_decode(v) for k, v in zip(keys, vals, strict=False)}
+    return None
+
+
+def _probe_data_fetcher(session: requests.Session, fn_id: str) -> bool:
+    """Return True if `fn_id` is the data-fetching server function.
+
+    Probes by calling /schedule/getdistricts (the cheapest known-safe API
+    path on the upstream backend) and checking whether the decoded response
+    has a `result` field whose value is a list (the shape the data fetcher
+    returns for that endpoint). Other server functions either 4xx, return a
+    Seroval error, or return a different shape.
+    """
+    payload = _seroval_encode_request("/schedule/getdistricts?search=")
+    try:
+        r = session.get(
+            _SERVER_FN_URL_TEMPLATE.format(fn_id=fn_id) + "?payload=" + quote(payload),
+            headers={
+                "Accept": "application/json",
+                "x-tsr-serverFn": "true",
+                "Sec-Fetch-Site": "same-origin",
+            },
+            timeout=8,
+        )
+    except requests.RequestException:
+        return False
+    if r.status_code != 200 or "json" not in r.headers.get("content-type", ""):
+        return False
+    try:
+        decoded = _seroval_decode(r.json())
+    except (ValueError, TypeError):
+        return False
+    return isinstance(decoded, dict) and isinstance(decoded.get("result"), list)
+
+
+def _candidate_fn_ids(session: requests.Session) -> list[str]:
+    """Scrape the live page and JS bundles for sha256-shaped server-fn ids.
+
+    Returns deduplicated candidates in the order they appear in the bundle,
+    or an empty list if scraping fails.
+    """
+    try:
+        html = session.get(_BASE_URL + "/", timeout=15).text
+    except requests.RequestException:
+        return []
+    bundles = re.findall(r"/assets/[A-Za-z0-9._-]+\.js", html)
+    seen: set[str] = set()
+    ordered: list[str] = []
+    for bundle in bundles:
+        try:
+            js = session.get(_BASE_URL + bundle, timeout=15).text
+        except requests.RequestException:
+            continue
+        # 64-char hex strings used as quoted string literals (the form
+        # `createServerFn` registers them in) — narrower than matching every
+        # hex blob, but agnostic to the minified factory's mangled name.
+        for fn_id in re.findall(r'[\'"`]([0-9a-f]{64})[\'"`]', js):
+            if fn_id not in seen:
+                seen.add(fn_id)
+                ordered.append(fn_id)
+    return ordered
+
+
+def _resolve_server_fn_id(session: requests.Session) -> str | None:
+    """Discover the data-fetching server-function id from the live JS bundle.
+
+    Returns None if discovery fails — the caller raises a descriptive error
+    rather than silently using a stale hardcoded id.
+    """
+    for fn_id in _candidate_fn_ids(session):
+        if _probe_data_fetcher(session, fn_id):
+            return fn_id
+    return None
+
+
+class _StaleFnId(Exception):
+    """Raised when a cached server-fn id stops responding correctly."""
+
+
+class Source:
+    def __init__(
+        self,
+        region: str,
+        street: str,
+        house_number: str,
+        district: str | None = None,
+        waste_object_ids: list[str | int] | None = None,
+    ):
+        if waste_object_ids is None:
+            waste_object_ids = []
+        if isinstance(waste_object_ids, (str, int)):
+            waste_object_ids = [waste_object_ids]
+        self._region = region
+        self._street = street
+        self._house_number = house_number
+        self._district = district
+        try:
+            self._waste_object_ids = [
+                int(x) for x in waste_object_ids if str(x).strip()
+            ]
+        except (ValueError, TypeError):
+            raise SourceArgumentException(
+                "waste_object_ids",
+                "waste_object_ids must be a list of numeric values",
+            ) from None
+        # Cached server-fn id, populated lazily on first fetch and
+        # invalidated when an upstream redeploy makes the cached id stale.
+        self._fn_id: str | None = None
+
+    def _ensure_fn_id(self, session: requests.Session) -> str:
+        if self._fn_id is None:
+            self._fn_id = _resolve_server_fn_id(session)
+        if self._fn_id is None:
+            raise Exception(
+                "Could not discover grafikai.svara.lt server-function id; "
+                "site structure may have changed unexpectedly"
+            )
+        return self._fn_id
+
+    def _raw_call(self, session: requests.Session, fn_id: str, api_path: str) -> dict:
+        payload = _seroval_encode_request(api_path)
+        r = session.get(
+            _SERVER_FN_URL_TEMPLATE.format(fn_id=fn_id) + "?payload=" + quote(payload),
+            headers={
+                "Accept": "application/json, application/x-tss-framed, application/x-ndjson",
+                "x-tsr-serverFn": "true",
+                # Upstream enforces Sec-Fetch-Site: same-origin on _serverFn
+                # calls — without it the edge returns 403 Forbidden.
+                "Sec-Fetch-Site": "same-origin",
+            },
+            timeout=20,
+        )
+        # Anything other than a normal JSON 200 implies the fn_id is no
+        # longer valid (most likely upstream redeployed). Signal stale and
+        # let the caller re-discover and retry once.
+        if r.status_code != 200 or "json" not in r.headers.get("content-type", ""):
+            raise _StaleFnId(f"fn_id {fn_id} returned HTTP {r.status_code}")
+        decoded = _seroval_decode(r.json()) or {}
+        if "result" not in decoded:
+            raise _StaleFnId(
+                f"fn_id {fn_id} returned unexpected shape: {r.text[:120]!r}"
+            )
+        return decoded
+
+    def _call(self, session: requests.Session, api_path: str) -> dict:
+        # On first call, discover. On a stale-id signal (e.g. upstream
+        # redeployed since we cached the id), invalidate and re-discover
+        # exactly once before failing.
+        for attempt in range(2):
+            fn_id = self._ensure_fn_id(session)
+            try:
+                return self._raw_call(session, fn_id, api_path)
+            except _StaleFnId:
+                self._fn_id = None
+                if attempt == 1:
+                    raise Exception(
+                        f"grafikai.svara.lt rejected request to {api_path!r} "
+                        "even after re-discovering the server-function id"
+                    ) from None
+        raise AssertionError("unreachable")
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+
+        contracts_path = "/schedule/getcontracts?" + urlencode(
+            {
+                "address": self._street,
+                "city": "",
+                "houseNumber": self._house_number,
+                "matchHouseNumber": "true",
+                "pageIndex": 0,
+                "pageSize": 50,
+                "region": self._region,
+                "subDistrict": self._district or "",
+            }
+        )
+        contracts_resp = self._call(session, contracts_path)
+        result = contracts_resp.get("result") or {}
+        rows = result.get("data") or []
+
+        entries: list[Collection] = []
+        for row in rows:
+            waste_object_id = row.get("wasteObjectId")
+            if waste_object_id is None:
+                continue
+            if (
+                self._waste_object_ids
+                and int(waste_object_id) not in self._waste_object_ids
+            ):
+                continue
+            description_plural = (row.get("descriptionPlural") or "").casefold()
+            description_fmt = (row.get("descriptionFmt") or "").title()
+
+            schedule_path = "/schedule/getschedule?" + urlencode(
+                {
+                    "address": "-",
+                    "houseNumber": "-",
+                    "pageIndex": 0,
+                    "pageSize": 50,
+                    "region": "-",
+                    "subDistrict": "-",
+                    "wasteObjectId": waste_object_id,
+                }
+            )
+            schedule_resp = self._call(session, schedule_path)
+            for d in schedule_resp.get("result") or []:
+                date_str = d.get("dateFmt") or (d.get("date") or "")[:10]
+                if not date_str:
+                    continue
+                try:
+                    date = datetime.strptime(date_str, "%Y-%m-%d").date()
+                except ValueError:
+                    continue
+                entries.append(
+                    Collection(
+                        date=date,
+                        t=description_fmt,
+                        icon=ICON_MAP.get(description_plural),
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,194 @@
+import xml.etree.ElementTree as ET
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Grand Besançon Métropole"
+DESCRIPTION = (
+    "Source for waste collection schedules in Grand Besançon Métropole, France."
+)
+URL = "https://www.grandbesancon.fr"
+COUNTRY = "fr"
+
+TEST_CASES = {
+    "Amagney, Rue de Besancon 1": {
+        "insee_code": "25014",
+        "street": "Rue de Besancon",
+        "house_number": "1",
+    },
+    "Besançon, chemin de la barre aux chevaux 1": {
+        "insee_code": "25056",
+        "street": "chemin de la barre aux chevaux",
+        "house_number": "1",
+    },
+}
+
+ICON_MAP = {
+    "Ordures ménagères": Icons.GENERAL_WASTE,
+    "Tri sélectif": Icons.RECYCLING,
+}
+
+WASTE_TYPE_MAP = {
+    "incinerable": "Ordures ménagères",
+    "recyclable": "Tri sélectif",
+}
+
+DAY_MAP = {
+    "lundi": 0,
+    "mardi": 1,
+    "mercredi": 2,
+    "jeudi": 3,
+    "vendredi": 4,
+    "samedi": 5,
+    "dimanche": 6,
+}
+
+STREETS_URL = "https://datasets.grandbesancon.fr/besanconfr.php"
+COLLECTION_URL = "https://datasets.grandbesancon.fr/dechets.php"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Find your commune's INSEE code at https://www.insee.fr. Enter your street name as shown on the Grand Besançon waste calendar at https://data.grandbesancon.fr/opendata/dataset/joursDeCollecteDechets.",
+    "fr": "Trouvez le code INSEE de votre commune sur https://www.insee.fr. Entrez le nom de votre rue tel qu'affiché sur le calendrier des déchets de Grand Besançon à https://data.grandbesancon.fr/opendata/dataset/joursDeCollecteDechets.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "insee_code": "5-digit INSEE code of your commune (e.g. 25014 for Amagney, 25056 for Besançon)",
+        "street": "Street name as shown in the Grand Besançon system",
+        "house_number": "House number (optional, helps filter results)",
+    },
+    "fr": {
+        "insee_code": "Code INSEE à 5 chiffres de votre commune (ex : 25014 pour Amagney, 25056 pour Besançon)",
+        "street": "Nom de la rue tel qu'affiché dans le système Grand Besançon",
+        "house_number": "Numéro de rue (optionnel, aide à filtrer les résultats)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "insee_code": "INSEE Code",
+        "street": "Street",
+        "house_number": "House Number",
+    },
+    "fr": {
+        "insee_code": "Code INSEE",
+        "street": "Rue",
+        "house_number": "Numéro",
+    },
+}
+
+
+class Source:
+    def __init__(
+        self,
+        insee_code: str,
+        street: str,
+        house_number: str | int | None = None,
+    ):
+        self._insee_code = str(insee_code).strip()
+        self._street = street.strip()
+        self._house_number = str(house_number).strip() if house_number else None
+
+    def _resolve_street_code(self) -> str:
+        params = {
+            "method": "getRuesCommuneAction",
+            "output": "json",
+            "insee": self._insee_code,
+        }
+        r = requests.get(STREETS_URL, params=params, timeout=30)
+        r.raise_for_status()
+        streets = r.json()
+
+        if not streets:
+            raise SourceArgumentNotFound("insee_code", self._insee_code)
+
+        for s in streets:
+            if s["librueweb"].lower() == self._street.lower():
+                return s["cdrue"]
+
+        suggestions = [s["librueweb"] for s in streets]
+        raise SourceArgumentNotFoundWithSuggestions("street", self._street, suggestions)
+
+    def _fetch_collection_xml(self) -> ET.Element:
+        params = {
+            "method": "getJourDeCollecteDechetsParAdresseAction",
+            "insee": self._insee_code,
+        }
+        if self._house_number:
+            params["numrue"] = self._house_number
+        r = requests.get(COLLECTION_URL, params=params, timeout=30)
+        r.raise_for_status()
+        return ET.fromstring(r.content)  # nosec B314
+
+    def fetch(self) -> list[Collection]:
+        cdrue = self._resolve_street_code()
+        root = self._fetch_collection_xml()
+
+        # Find the address matching our street code
+        target_addr = None
+        for addr in root.findall(".//adresse"):
+            rue = addr.find("rue")
+            if rue is not None and rue.get("id") == cdrue.lstrip("0"):
+                num = addr.find("numero")
+                if self._house_number and num is not None:
+                    if num.text != self._house_number:
+                        continue
+                target_addr = addr
+                break
+
+        if target_addr is None:
+            raise SourceArgumentNotFound("street", self._street)
+
+        infos = target_addr.find("infosCollecte")
+        if infos is None:
+            return []
+
+        today = date.today()
+        end_date = today + timedelta(days=365)
+        entries: list[Collection] = []
+
+        for jour in infos.findall("jourDeCollecte"):
+            waste_api_type = jour.get("type", "")
+            semaine = jour.get("semaine")
+            day_name = jour.text
+            if not day_name:
+                continue
+
+            weekday = DAY_MAP.get(day_name.lower().strip())
+            if weekday is None:
+                continue
+
+            waste_type = WASTE_TYPE_MAP.get(waste_api_type, waste_api_type)
+
+            # Generate dates for this weekday
+            d = today
+            # Advance to the next occurrence of this weekday
+            days_ahead = weekday - d.weekday()
+            if days_ahead < 0:
+                days_ahead += 7
+            d = d + timedelta(days=days_ahead)
+
+            while d <= end_date:
+                iso_week = d.isocalendar()[1]
+                include = True
+                if (semaine == "impaires" and iso_week % 2 == 0) or (
+                    semaine == "paires" and iso_week % 2 == 1
+                ):
+                    include = False
+
+                if include:
+                    entries.append(
+                        Collection(
+                            date=d,
+                            t=waste_type,
+                            icon=ICON_MAP.get(waste_type),
+                        )
+                    )
+                d += timedelta(weeks=1)
+
+        return entries

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

@@ -0,0 +1,160 @@
+import base64
+import json
+import re
+from datetime import date, datetime, timedelta
+
+from bs4 import BeautifulSoup
+from curl_cffi import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Great Yarmouth Borough Council"
+DESCRIPTION = "Source for waste collection services for Great Yarmouth Borough Council, Norfolk, UK."
+URL = "https://myaccount.great-yarmouth.gov.uk"
+COUNTRY = "uk"
+TEST_CASES = {
+    "64 Black Street Martham NR29 4PR": {"uprn": "100090834016"},
+    "1 Hobland Barns Bradwell NR31 9BS": {"uprn": "10023466513"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "An easy way to discover your Unique Property Reference Number (UPRN) is by going to https://www.findmyaddress.co.uk/ and entering your address details.",
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+    }
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Garden Waste": Icons.GARDEN,
+    "Recycling": Icons.RECYCLING,
+}
+
+_BASE_URL = "https://myaccount.great-yarmouth.gov.uk"
+_FORM_NAME = "WASTECOLLECTIONCALENDARV2"
+_HEADERS = {
+    "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"
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn)
+
+    def _get_icon(self, waste_type: str) -> str | None:
+        for key, icon in ICON_MAP.items():
+            if key.lower() in waste_type.lower():
+                return icon
+        return None
+
+    def _parse_date(self, date_str: str) -> date | None:
+        """Parse 'Friday 22 May' style date strings, inferring the year."""
+        today = date.today()
+        year = today.year
+        try:
+            d = datetime.strptime(f"{date_str.strip()} {year}", "%A %d %B %Y").date()
+            if (d - today) < timedelta(days=-31):
+                d = d.replace(year=d.year + 1)
+            return d
+        except ValueError:
+            return None
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session(impersonate="chrome")
+        session.headers.update(_HEADERS)
+
+        # Step 1: GET the form page and extract session tokens.
+        r = session.get(f"{_BASE_URL}/find-my-waste-collection-days")
+        r.raise_for_status()
+
+        m = re.search(r'action="([^"]*processsubmission[^"]*)"', r.text)
+        if not m:
+            raise ValueError("Could not find form action URL on collection page")
+        action = m.group(1).replace("&amp;", "&")
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        form = soup.find("form", {"id": f"{_FORM_NAME}_FORM"})
+        if not form:
+            raise ValueError("Could not find waste collection form on page")
+
+        form_data = {
+            inp.get("name"): inp.get("value", "")
+            for inp in form.find_all("input")
+            if inp.get("name")
+        }
+
+        # Step 2: Submit the form with the UPRN to retrieve the collection schedule.
+        # The GOSS Forms server resolves the UPRN server-side; no postcode is required.
+        form_data.update(
+            {
+                f"{_FORM_NAME}_ADDRESS_UPRN": self._uprn,
+                f"{_FORM_NAME}_ADDRESS_COUNTRY": "United Kingdom",
+                f"{_FORM_NAME}_ADDRESS_ADDRESSKNOWN": "true",
+                f"{_FORM_NAME}_ADDRESS_FINDANADDRESS": "true",
+                f"{_FORM_NAME}_FORMACTION_NEXT": f"{_FORM_NAME}_ADDRESS_LOOKUPVBUTTON",
+                f"{_FORM_NAME}_ADDRESS_LOOKUPVBUTTON": "Confirm Address",
+            }
+        )
+
+        r2 = session.post(action, data=form_data)
+        r2.raise_for_status()
+
+        # Step 3: Extract the collection schedule from the Base64-encoded FormData.
+        m_fd = re.search(rf"var {_FORM_NAME}FormData = \"([^\"]+)\"", r2.text)
+        if not m_fd:
+            raise ValueError("Could not find form data in the schedule response")
+
+        fd = json.loads(base64.b64decode(m_fd.group(1)).decode("utf-8"))
+        showschedule = fd.get("LOOKUP_1", {}).get("SHOWSCHEDULE", "")
+        if not showschedule:
+            raise ValueError(
+                f"No collection schedule found for UPRN {self._uprn}. "
+                "Ensure the UPRN is for a property within Great Yarmouth Borough."
+            )
+
+        # Step 4: Parse the schedule HTML.
+        schedule_soup = BeautifulSoup(showschedule, "html.parser")
+        entries: list[Collection] = []
+        seen: set[tuple] = set()
+
+        for div in schedule_soup.find_all("div", class_="collection-area"):
+            detail = div.find("div", class_="collection-detail")
+            if not detail:
+                continue
+            b_tag = detail.find("b")
+            if not b_tag:
+                continue
+
+            date_str = b_tag.get_text(strip=True)
+            type_text = (
+                detail.get_text(separator=" ", strip=True).replace(date_str, "").strip()
+            )
+            # Strip the trailing "will be emptied" boilerplate
+            type_clean = re.sub(r"\s*will be emptied\s*$", "", type_text).strip()
+
+            cdate = self._parse_date(date_str)
+            if not cdate:
+                continue
+
+            key = (cdate, type_clean)
+            if key in seen:
+                continue
+            seen.add(key)
+
+            entries.append(
+                Collection(
+                    date=cdate,
+                    t=type_clean,
+                    icon=self._get_icon(type_clean),
+                )
+            )
+
+        return entries