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

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

@@ -0,0 +1,220 @@
+import re
+
+from waste_collection_schedule import (  # type: ignore[attr-defined]
+    Collection,
+    Icons,
+)
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.junker_app import (
+    AreaRequired,
+    Junker,
+    replace_accents,
+)
+
+TITLE = "CIDIU S.p.A."
+DESCRIPTION = (
+    "Source for CIDIU waste collection services for the north-west Turin province"
+)
+URL = "https://cidiu.it/"
+COUNTRY = "it"
+
+# CIDIU retired its own calendar (cidiu-processer.php) and now publishes the
+# schedules through the Junker app, one Junker "municipality" per town, with one
+# zone per street or range of street numbers.
+TEST_CASES = {
+    "Collegno": {
+        "city": "COLLEGNO",
+        "street": "VIA CONDOVE",
+        "street_number": "107",
+    },
+    "Grugliasco": {
+        "city": "GRUGLIASCO",
+        "street": "VIALE GRAMSCI",
+        "street_number": "18",
+    },
+    "Rivoli": {
+        "city": "RIVOLI",
+        "street": "CORSO SUSA",
+        "street_number": 124,
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "city": "City",
+        "street": "Street",
+        "street_number": "Street number",
+    },
+    "it": {
+        "city": "Comune",
+        "street": "Via",
+        "street_number": "Numero civico",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "city": "Town served by CIDIU, e.g. Collegno",
+        "street": "Street name without the number",
+        "street_number": "Street number",
+    },
+    "it": {
+        "city": "Comune servito da CIDIU, ad esempio Collegno",
+        "street": "Nome della via senza il numero civico",
+        "street_number": "Numero civico",
+    },
+}
+
+# Junker's labels mapped back onto the ones CIDIU's own calendar used, so that
+# switching to Junker does not rename the waste types users filter on.
+TYPE_MAP = {
+    "General waste collection": ("Indifferenziato", Icons.GENERAL_WASTE),
+    "Organic waste": ("Organico", Icons.BIO_KITCHEN),
+    "Paper": ("Carta", Icons.PAPER),
+    "Plastic": ("Plastica", Icons.RECYCLING),
+    "Glass/Cans": ("Vetro e lattine", Icons.GLASS),
+}
+
+_RANGE_RE = re.compile(r"(\d+)\s*[a-z]?\s+a\s+(?:civico\s*)?(\d+)")
+_EXCEPTION_RE = re.compile(r"tranne\s+(?:civico\s*)?(\d+)")
+_QUALIFIER_WORD_RE = re.compile(
+    r"(?:da|dal|a|al|e|civico|civici|pari|dispari|tranne|\d+[a-z]?)"
+)
+
+# Specificity of a zone for a house number: a zone named for exactly that number
+# beats a range or parity zone, which beats the catch-all zone for the street.
+_CATCH_ALL, _RANGE, _EXACT = 0, 1, 2
+
+
+def _normalize(text: str) -> str:
+    return re.sub(r"\s+", " ", replace_accents(text).lower()).strip()
+
+
+def _is_qualifier(words: list[str]) -> bool:
+    """Whether trailing words describe house numbers rather than a street name.
+
+    "da vinci" (VIA LEONARDO DA VINCI) or "66 martiri" (PIAZZA 66 MARTIRI) are
+    parts of a street name; "11", "da 1 a 15" or "civici pari" are qualifiers.
+    """
+    return all(_QUALIFIER_WORD_RE.fullmatch(w) for w in words) and any(
+        re.fullmatch(r"\d+[a-z]?|pari|dispari", w) for w in words
+    )
+
+
+def _split_zone_name(zone_name: str) -> tuple[str, str]:
+    """Split a Junker zone name into (street, qualifier).
+
+    Junker names its zones like "VIA CONDOVE da civico 2 a civico 124 e da civico
+    1 a civico 123", "CORSO SUSA pari da 2 a 314 dispari da 17 a 315",
+    "Viale Bruno Radich 11" or "Via Roma civici pari".
+    """
+    words = _normalize(zone_name).replace("(", " ").replace(")", " ").split()
+    for i in range(1, len(words)):
+        if _is_qualifier(words[i:]):
+            return " ".join(words[:i]), " ".join(words[i:])
+    return " ".join(words), ""
+
+
+def _match_rank(qualifier: str, number: int) -> int | None:
+    """Specificity with which a zone qualifier covers `number`, None if it doesn't."""
+    if not qualifier:
+        return _CATCH_ALL
+    excluded = {int(m.group(1)) for m in _EXCEPTION_RE.finditer(qualifier)}
+    if number in excluded:
+        return None
+    if not _RANGE_RE.search(qualifier):
+        if "pari" in qualifier:  # "civici pari" / "civici dispari", no numbers
+            odd = "dispari" in qualifier
+            return _RANGE if bool(number % 2) == odd else None
+        # A bare number: the zone is dedicated to that house number.
+        listed = {int(n) for n in re.findall(r"\d+", qualifier)}
+        return _EXACT if number in listed else None
+    # Split into segments so that parity words apply to the range that follows
+    # them ("pari da 2 a 314 dispari da 17 a 315").
+    for segment in re.split(r"(?=\bpari\b|\bdispari\b)", qualifier):
+        parity_odd = "dispari" in segment
+        parity_even = not parity_odd and "pari" in segment
+        for match in _RANGE_RE.finditer(segment):
+            low, high = int(match.group(1)), int(match.group(2))
+            if not low <= number <= high:
+                continue
+            if parity_even and number % 2:
+                continue
+            if parity_odd and not number % 2:
+                continue
+            return _RANGE
+    return None
+
+
+class Source:
+    def __init__(self, street, street_number, city):
+        self._street = street
+        self._street_number = str(street_number)
+        self._city = city
+
+    def _find_zone(self, zones: list[tuple[str, int]]) -> int:
+        """Return the id of the zone that covers the configured address."""
+        street = _normalize(self._street)
+        match = re.match(r"\d+", self._street_number.strip())
+        if match is None:
+            raise SourceArgumentNotFound(
+                "street_number", self._street_number, "Enter a street number."
+            )
+        number = int(match.group(0))
+
+        parsed = [(name, id_, *_split_zone_name(name)) for name, id_ in zones]
+        same_street = [
+            (name, id_, qualifier)
+            for name, id_, base, qualifier in parsed
+            if base == street
+        ]
+        if not same_street:
+            # Junker often spells the street out in full ("Viale Antonio
+            # Gramsci") where CIDIU's old calendar used "VIALE GRAMSCI".
+            tokens = set(street.split())
+            same_street = [
+                (name, id_, qualifier)
+                for name, id_, base, qualifier in parsed
+                if tokens <= set(base.split())
+            ]
+        if not same_street:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street",
+                self._street,
+                sorted({name for name, _id in zones}),
+            )
+
+        ranked = [
+            (rank, name, id_)
+            for name, id_, qualifier in same_street
+            if (rank := _match_rank(qualifier, number)) is not None
+        ]
+        if not ranked:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street_number", self._street_number, [n for n, _i, _q in same_street]
+            )
+        best = max(rank for rank, _n, _i in ranked)
+        candidates = [(name, id_) for rank, name, id_ in ranked if rank == best]
+        if len(candidates) > 1:
+            raise SourceArgAmbiguousWithSuggestions(
+                "street", self._street, [name for name, _id in candidates]
+            )
+        return candidates[0][1]
+
+    def fetch(self) -> list[Collection]:
+        try:
+            # Towns without per-street zones return their calendar right away.
+            collections = Junker(self._city, use_embed_url=False).fetch()
+        except AreaRequired as e:
+            zone_id = self._find_zone(e.areas)
+            collections = Junker(self._city, area=zone_id, use_embed_url=False).fetch()
+
+        entries = []
+        for c in collections:
+            label, icon = TYPE_MAP.get(c.type, (c.type, c.icon))
+            entries.append(Collection(date=c.date, t=label, icon=icon))
+        return entries

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

@@ -0,0 +1,67 @@
+from datetime import date, datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Circulus"
+DESCRIPTION = "Source for circulus.nl waste collection."
+URL = "https://mijn.circulus.nl"
+
+TEST_CASES = {
+    "Test1": {"postal_code": "7206AC", "house_number": "1"},
+}
+
+ICON_MAP = {
+    "REST": Icons.GENERAL_WASTE,
+    "ZWAKRA": Icons.RECYCLING,
+    "GFT": Icons.BIO_KITCHEN,
+    "PAP": Icons.PAPER,
+}
+
+WASTE_MAP = {
+    "REST": "Zwarte Kliko",
+    "ZWAKRA": "Glas & Blik",
+    "GFT": "Groene Kliko",
+    "PAP": "Papier",
+}
+API_URL = "https://mijn.circulus.nl"
+
+
+class Source:
+    def __init__(self, postal_code, house_number):
+        self._postal_code = postal_code
+        self._house_number = house_number
+
+    def fetch(self):
+        location_data = {"zipCode": self._postal_code, "number": self._house_number}
+        entries = []
+
+        # Make a post request and store the cookies
+        r = requests.post(f"{API_URL}/register/zipcode.json", data=location_data)
+        r.raise_for_status()
+
+        cookies = r.cookies
+
+        # Check if the CB_SESSION cookie exists
+        if "CB_SESSION" in cookies:
+            # Make a GET request and store the JSON data
+            req_params = {
+                "from": date.today().strftime("%Y-%m-%d"),
+                "till": (date.today() + timedelta(days=365)).strftime("%Y-%m-%d"),
+            }
+
+            r = requests.get(
+                f"{API_URL}/afvalkalender.json", params=req_params, cookies=cookies
+            )
+            r.raise_for_status()
+
+            for item in r.json()["customData"]["response"]["garbage"]:
+                for newdate in item["dates"]:
+                    entries.append(
+                        Collection(
+                            date=datetime.strptime(newdate, "%Y-%m-%d").date(),
+                            t=WASTE_MAP.get(item["code"], item["code"]),
+                            icon=ICON_MAP.get(item["code"]),
+                        )
+                    )
+        return entries

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

@@ -0,0 +1,101 @@
+from datetime import datetime
+
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.CitiesAppsCom import SERVICE_MAP, CitiesApps
+
+EXTRA_INFO = SERVICE_MAP
+TITLE = "App CITIES"
+DESCRIPTION = "Source for App CITIES."
+URL = "https://citiesapps.com"
+TEST_CASES = {
+    "Fürstenfeld Haushalt Altenmarkt": {
+        "city": "Fürstenfeld",
+        "calendar": "Haushalt Altenmarkt",
+        "email": "!secret citiesapps_com_email",
+        "phone": "!secret citiesapps_com_phone",
+        "password": "!secret citiesapps_com_password",
+    },
+    "Buch - St. Magdalena Buch - St. Magdalena": {
+        "city": "Buch - St. Magdalena",
+        "calendar": "Buch - St. Magdalena",
+        "email": "!secret citiesapps_com_email",
+        "phone": "!secret citiesapps_com_phone",
+        "password": "!secret citiesapps_com_password",
+    },
+    "Rudersdorf Wiesengasse": {
+        "city": "Rudersdorf",
+        "calendar": "Wiesengasse",
+        "email": "!secret citiesapps_com_email",
+        "phone": "!secret citiesapps_com_phone",
+        "password": "!secret citiesapps_com_password",
+    },
+    "Lieboch": {
+        "city": "Lieboch",
+        "calendar": "Lieboch",
+        "email": "!secret citiesapps_com_email",
+        "phone": "!secret citiesapps_com_phone",
+        "password": "!secret citiesapps_com_password",
+    },
+}
+COUNTRY = "at"
+
+
+ICON_MAP = {
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Biomüll": Icons.BIO_KITCHEN,
+    "Altpapier": Icons.PAPER,
+    "Papier": Icons.PAPER,
+    "Leichtfraktion": Icons.RECYCLING,
+    "Leichtverpackung": Icons.PLASTIC_PACKAGING,
+    "Leicht-": Icons.RECYCLING,
+    "Gelber": Icons.RECYCLING,
+    "Sonder-": Icons.BULKY,
+    "Abfallwirtschaftszentrum": Icons.GENERAL_WASTE,
+    "Strauchschnitt": Icons.GARDEN,
+    "Metallverpackung": Icons.METAL,
+}
+
+
+class Source:
+    def __init__(self, city: str, calendar: str, password, email=None, phone=None):
+        self._city: str = city
+        self._calendar: str = calendar
+        self._email: str | None = email
+        self._phone: str | None = phone
+        self._password: str = password
+
+    def fetch(self):
+        cities_apps = CitiesApps(
+            email=self._email, phone=self._phone, password=self._password
+        )
+
+        garbage_plans = cities_apps.fetch_garbage_plans(self._city, self._calendar)
+
+        if garbage_plans["is_v2"]:
+            return self.convert_v2(garbage_plans["data"])
+        return self.convert_v1(garbage_plans["data"])
+
+    def convert_v2(self, garbage_plans):
+        entries = []
+        for garbage_plan in garbage_plans:
+            bin_type = garbage_plan["garbageTypeSettings"]["displayName"]
+            icon = ICON_MAP.get(bin_type.split(" ")[0])  # Collection icon
+
+            date = datetime.strptime(
+                garbage_plan["date"], "%Y-%m-%dT%H:%M:%S.%fZ"
+            ).date()
+            entries.append(Collection(date=date, t=bin_type, icon=icon))
+
+        return entries
+
+    def convert_v1(self, garbage_plans):
+        entries = []
+        for garbage_plan in garbage_plans:
+            bin_type = garbage_plan["garbage_type"]["name"]
+            icon = ICON_MAP.get(bin_type.split(" ")[0])  # Collection icon
+
+            for date_string in garbage_plan["dates"]:
+                date = datetime.strptime(date_string, "%Y-%m-%d").date()
+                entries.append(Collection(date=date, t=bin_type, icon=icon))
+
+        return entries

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

@@ -0,0 +1,199 @@
+import urllib.parse
+from datetime import datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "City of Parramatta"
+DESCRIPTION = "Source script for cityofparramatta.nsw.gov.au"
+URL = "https://www.cityofparramatta.nsw.gov.au"
+COUNTRY = "au"
+TEST_CASES = {
+    "126 Church Street": {"address": "126 Church Street Parramatta"},
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {"address": "Address"},
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Full address including suburb (e.g. '126 Church Street Parramatta')"
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your full address including the suburb. Example: `126 Church Street Parramatta`",
+}
+
+API_MAP_URL = "https://services6.arcgis.com/NrOjMi9LSYL3MUze/arcgis/rest/services/CoP_Garbage_Recyle_July2021/FeatureServer/0/query"
+GEOCODE_URL = "https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates"
+
+ICON_MAP = {
+    "General Waste (Red Bin)": Icons.GENERAL_WASTE,
+    "Recycling (Yellow Bin)": Icons.PLASTIC_PACKAGING,
+    "Garden Organics (Green Bin)": Icons.GARDEN,
+}
+
+# The reference date points to a known Monday for an "Area 1" Recycling week.
+# Adjust this if the parity is wrong. Area 2 will be the week after.
+REFERENCE_DATE_AREA_1_RECYCLING = datetime(2024, 1, 1).date()
+
+
+class Source:
+    def __init__(self, address):
+        self._address = address
+
+    def get_collection_dates(self, collection_day_str, is_area_1, is_recycling):
+        # Determine 0-6 weekday
+        weekdays = [
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday",
+            "Sunday",
+        ]
+        if collection_day_str not in weekdays:
+            return []
+
+        target_wday = weekdays.index(collection_day_str)
+        today = datetime.now().date()
+
+        # Calculate days until the next occurrence of this weekday
+        days_until = (target_wday - today.weekday() + 7) % 7
+        next_date = today + timedelta(days=days_until)
+
+        # Decide the reference week for this bin and area
+        # For Parramatta, FOGO and Recycling are alternating weeks.
+        # Area 1: Recycling Week X, FOGO Week X+1
+        # Area 2: Recycling Week X+1, FOGO Week X
+
+        # Base reference date
+        ref_base = REFERENCE_DATE_AREA_1_RECYCLING
+
+        # If it's Area 2, shift the reference for Recycling by 7 days
+        if not is_area_1:
+            ref_base += timedelta(days=7)
+
+        # If it's FOGO (not recycling), shift by 7 days to alternate
+        if not is_recycling:
+            ref_base += timedelta(days=7)
+
+        # Calculate full weeks between ref_base and next_date
+        days_diff = (next_date - ref_base).days
+
+        # If the number of weeks is odd, it's the wrong week, so add 7 days
+        if (days_diff // 7) % 2 != 0:
+            next_date += timedelta(days=7)
+
+        return [
+            next_date,
+            next_date + timedelta(days=14),
+            next_date + timedelta(days=28),
+        ]
+
+    def fetch(self):
+        address = urllib.parse.quote(self._address)
+
+        # 1. Geocode the address to find coordinates
+        geo_params = {
+            "f": "json",
+            "SingleLine": address,
+            "outFields": "Match_addr",
+            "maxLocations": "1",
+        }
+        r_geo = requests.get(GEOCODE_URL, params=geo_params, timeout=30)
+        r_geo.raise_for_status()
+
+        candidates = r_geo.json().get("candidates", [])
+        if not candidates:
+            raise SourceArgumentNotFound("address", self._address)
+
+        location = candidates[0].get("location")
+        if not location:
+            raise SourceArgumentNotFound("address", self._address)
+
+        lat, lon = location["y"], location["x"]
+
+        # 2. Query Parramatta Map API
+        # Using spatial relationship 'Intersects' with the point geometry
+        api_params = {
+            "f": "json",
+            "outFields": "*",
+            "returnGeometry": "false",
+            "spatialRel": "esriSpatialRelIntersects",
+            "geometryType": "esriGeometryPoint",
+            "geometry": f"{lon},{lat}",
+            "inSR": "4326",  # Standard lat/long WKID
+        }
+
+        r_api = requests.get(API_MAP_URL, params=api_params, timeout=30)
+        r_api.raise_for_status()
+
+        features = r_api.json().get("features", [])
+        if not features:
+            raise SourceArgumentNotFound("address", self._address)
+
+        properties = features[0].get("attributes", {})
+
+        collection_day = properties.get("DAY", "").strip().capitalize()
+        week_str = properties.get("WEEK", "").strip().lower()
+
+        if not collection_day or not week_str:
+            raise SourceArgumentNotFound("address", self._address)
+
+        is_area_1 = "area 1" in week_str
+
+        entries = []
+
+        today = datetime.now().date()
+        weekdays = [
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday",
+            "Sunday",
+        ]
+        target_wday = weekdays.index(collection_day)
+
+        # General Waste is weekly
+        days_until_general = (target_wday - today.weekday() + 7) % 7
+        next_general = today + timedelta(days=days_until_general)
+        for i in range(4):
+            entries.append(
+                Collection(
+                    date=next_general + timedelta(days=i * 7),
+                    t="General Waste (Red Bin)",
+                    icon=ICON_MAP.get("General Waste (Red Bin)"),
+                )
+            )
+
+        # Recycling (Fortnightly)
+        recycling_dates = self.get_collection_dates(
+            collection_day, is_area_1, is_recycling=True
+        )
+        for d in recycling_dates:
+            entries.append(
+                Collection(
+                    date=d,
+                    t="Recycling (Yellow Bin)",
+                    icon=ICON_MAP.get("Recycling (Yellow Bin)"),
+                )
+            )
+
+        # Garden Organics / FOGO (Weekly since late 2024 rollout)
+        for i in range(4):
+            entries.append(
+                Collection(
+                    date=next_general + timedelta(days=i * 7),
+                    t="Garden Organics (Green Bin)",
+                    icon=ICON_MAP.get("Garden Organics (Green Bin)"),
+                )
+            )
+
+        return entries