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

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

@@ -0,0 +1,112 @@
+import datetime
+import logging
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "EGN Abfallkalender"
+DESCRIPTION = "Source for EGN Abfallkalender"
+URL = "https://www.egn-abfallkalender.de"
+TEST_CASES = {
+    "Grevenbroich": {
+        "city": "Grevenbroich",
+        "district": "Noithausen",
+        "street": "Von-Immelhausen-Straße",
+        "housenumber": 12,
+    },
+    "Dormagen": {
+        "city": "Dormagen",
+        "district": "Hackenbroich",
+        "street": "Aggerstraße",
+        "housenumber": 2,
+    },
+    "Grefrath": {
+        "city": "Grefrath",
+        "district": "Grefrath",
+        "street": "An Haus Bruch",
+        "housenumber": 18,
+    },
+    "Schwalmtal Amern Hauptstraße 1": {
+        "city": "Schwalmtal",
+        "district": "Amern",
+        "street": "Hauptstrasse",
+        "housenumber": 1,
+    },
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+API_URL = "https://www.egn-abfallkalender.de/kalender"
+ICON_MAP = {
+    "Grau": Icons.GENERAL_WASTE,
+    "Gelb": Icons.PLASTIC_PACKAGING,
+    "Blau": Icons.PAPER,
+    "Braun": Icons.ORGANIC,
+    "Bio": Icons.ORGANIC,
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "city": "Ort",
+        "district": "Ortsteil",
+        "street": "Straße",
+        "housenumber": "Hausnummer",
+    }
+}
+
+
+class Source:
+    def __init__(self, city, district, street, housenumber):
+        self._city = city
+        self._district = district
+        self._street = street
+        self._housenumber = housenumber
+
+    def fetch(self):
+        s = requests.session()
+        r = s.get(API_URL)
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+        tag = soup.find("meta", {"name": "csrf-token"})
+        if tag is None:
+            return []
+
+        headers = {"x-csrf-token": tag["content"]}
+        post_data = {
+            "city": self._city,
+            "district": self._district,
+            "street": self._street,
+            "street_number": self._housenumber,
+        }
+        r = s.post(API_URL, data=post_data, headers=headers)
+
+        data = r.json()
+
+        if data.get("error"):
+            raise Exception(
+                "\n".join(
+                    [
+                        f"{type} - {errormsg}"
+                        for type, errormsg in data["errors"].items()
+                    ]
+                )
+            )
+
+        entries = []
+        for year, months in data["waste_discharge"].items():
+            for month, days in months.items():
+                for day, types in days.items():
+                    date = datetime.datetime(
+                        year=int(year), month=int(month), day=int(day)
+                    ).date()
+                    for type in types:
+                        color = (
+                            data["trash_type_colors"].get(str(type).lower(), type)
+                            or type
+                        ).capitalize()
+                        entries.append(
+                            Collection(date=date, t=color, icon=ICON_MAP.get(color))
+                        )
+
+        return entries

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

@@ -0,0 +1,107 @@
+import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.ICS import ICS
+
+# URL, DESCRIPTION  and TITLE of the website
+TITLE = "Eigenbetrieb Abfallwirtschaft Landkreis Spree-Neiße"
+DESCRIPTION = "Source for Eigenbetrieb Abfallwirtschaft Landkreis Spree-Neiße."
+URL = "https://www.eigenbetrieb-abfallwirtschaft.de"
+COUNTRY = "de"
+TEST_CASES = {
+    "Forst (Lausitz), Rosenweg": {"city": "4", "street": "344"},
+    "Peitz, Am See": {"city": "8", "street": "1077"},
+    "Guben, Altsprucke": {"city": "5", "street": "410"},
+    "Spremberg, Gartenstrasse": {"city": 10, "street": 701},
+}
+
+ICON_MAP = {
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Biotonne": Icons.BIO_KITCHEN,
+    "Papiercontainer": Icons.PAPER,
+    "Gelbe(r) Sack/Tonne": Icons.RECYCLING,
+}
+PARAM_TRANSLATIONS = {
+    "de": {
+        "city": "Ort",
+        "street": "Straße",
+    }
+}
+
+
+class Source:
+    def __init__(self, city: str, street: str):
+        self._city: str = city
+        self._street: str = street
+        self._ics = ICS()
+
+    def fetch(self):
+        # get the current year
+        now = datetime.datetime.now()
+        year = now.year
+        # build the urls and fetch the data ...
+        # for this year ...
+        url_this_year = (
+            f"{URL}/termine/abfuhrtermine/{year}/{self._city}/{self._street}.html"
+        )
+        entries = self.get_data(url_this_year)
+        # and in december for the next year
+        if now.month == 12:
+            try:
+                url_next_year = f"{URL}/termine/abfuhrtermine/{year + 1}/{self._city}/{self._street}.html"
+                entries += self.get_data(url_next_year)
+            except Exception:
+                pass
+        return entries
+
+    def get_data(self, url):
+        # download the site
+        response = requests.get(url)
+
+        # check if the request was successful
+        if response.status_code != 200:
+            raise Exception(
+                f"Error loading page {URL}, status code {response.status_code}."
+            )
+        # parse the response
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # check for an input element named 'ics'
+        input_element = soup.find("input", {"name": "ics"})
+
+        # check if the input element was found
+        if not input_element:
+            raise Exception("Didn't find the input named ics.")
+        # try to find the parent form
+        form = input_element.find_parent("form")
+
+        # check if the parent form was found
+        if not form:
+            raise Exception("Didn't find the ics request formular.")
+
+        # extract the formular inputs
+        form_data = {}
+        for input_tag in form.find_all("input"):
+            name = input_tag.get("name")
+            value = input_tag.get("value", "")
+            form_data[name] = value
+
+        # extract the url (convert the relative url to a complete one)
+        action_url = URL + form.get("action")
+
+        # send the formular to fetch the ics file
+        response = requests.post(action_url, data=form_data)
+        response.raise_for_status()
+        response.encoding = "utf-8"
+        # process the response
+        dates = self._ics.convert(response.text)
+        entries = []
+        for d in dates:
+            icon = ICON_MAP.get(d[1].split(" ")[0])
+            if icon is None:
+                icon = ICON_MAP.get(d[1])
+            entries.append(Collection(d[0], d[1], icon=icon))
+
+        return entries

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

@@ -0,0 +1,98 @@
+import re
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Eilenburg"
+DESCRIPTION = "Source for waste collection in Eilenburg (Saxony, Germany)."
+URL = "https://www.eilenburg.de"
+COUNTRY = "de"
+TEST_CASES = {
+    "EB Berg + EB 1": {"areas": ["EB Berg", "EB 1"]},
+    "EB Stadt + EB 3": {"areas": ["EB Stadt", "EB 3"]},
+    "EB Ortsteile": {"areas": ["EB Ortsteile Dörfer"]},
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "areas": "Entsorgungsbezirke",
+    },
+    "en": {
+        "areas": "Collection areas",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "de": {
+        "areas": "Liste der Entsorgungsbezirke, z. B. ['EB Berg', 'EB 1']. Restmüll/Papier-Bezirke: EB Berg, EB Stadt, EB Ost, EB Ortsteile Dörfer. Gelber-Sack-Bezirke: EB 1 bis EB 5.",
+    },
+    "en": {
+        "areas": "List of collection areas, e.g. ['EB Berg', 'EB 1']. Residual/paper areas: EB Berg, EB Stadt, EB Ost, EB Ortsteile Dörfer. Yellow-bag areas: EB 1 to EB 5.",
+    },
+}
+
+CALENDAR_PAGE_URL = (
+    "https://www.eilenburg.de/portal/seiten/abfallwirtschaft-900000136-27670.html"
+)
+
+ICS_LINK_PATTERN = re.compile(
+    r'data-extension="ICS"[^>]*href="(https://www\.eilenburg\.de/downloads/datei/[^"]+)"[^>]*title="[^"]*"([^&]+\.ics)"'
+)
+AREA_NAME_PATTERN = re.compile(r"- (EB .+?)\.ics$")
+
+
+class Source:
+    def __init__(self, areas: list[str]):
+        self._areas = areas
+        self._ics = ICS()
+
+    def fetch(self) -> list[Collection]:
+        # Fetch the waste calendar page
+        r = requests.get(
+            CALENDAR_PAGE_URL,
+            headers={"User-Agent": "Mozilla/5.0"},
+            timeout=30,
+        )
+        r.raise_for_status()
+        html = r.text
+
+        # Extract all ICS download links and their area names
+        available: dict[str, str] = {}
+        for ics_url, filename in ICS_LINK_PATTERN.findall(html):
+            m = AREA_NAME_PATTERN.search(filename)
+            if m:
+                area_name = m.group(1)
+                available[area_name] = ics_url
+
+        entries: list[Collection] = []
+        for area in self._areas:
+            # Case-insensitive match
+            matched_url = None
+            for available_area, ics_url in available.items():
+                if available_area.lower() == area.lower():
+                    matched_url = ics_url
+                    break
+
+            if matched_url is None:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "areas",
+                    area,
+                    list(available.keys()),
+                )
+
+            ics_r = requests.get(
+                matched_url,
+                headers={"User-Agent": "Mozilla/5.0"},
+                timeout=30,
+            )
+            ics_r.raise_for_status()
+            ics_text = ics_r.text
+
+            for date, waste_type in self._ics.convert(ics_text):
+                entries.append(Collection(date, waste_type))
+
+        return entries

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

@@ -0,0 +1,103 @@
+# This source uses the already existing API for c_trace but with some name changes and it does not use the ical file, so it got its own source file.
+
+import datetime
+import logging
+
+import requests as req
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+_LOOGGER = logging.getLogger(__name__)
+
+TITLE = "Czerwonak, Murowana Goślina, Oborniki"
+DESCRIPTION = (
+    "Source for eko-tom.pl. Municipalities: Czerwonak, Murowana Goślina, Oborniki"
+)
+URL = "https://www.eko-tom.pl"
+
+TEST_CASES = {
+    "Czerwonak": {"city": "Czerwonak", "street": "Źródlana", "nr": "39"},
+    "BIAŁĘŻYN": {"city": "BIAŁĘŻYN", "street": "BIAŁĘŻYN", "nr": "1/A"},
+}
+
+API_URL = "https://web.c-trace.de/ekotom-abfallkalender/(S(y0ommq52pdbwa0jek4oqqzgr))/kalendarzodpadow/abc?Ort={city}&Strasse={street}&Hausnr={nr}"
+
+ICON_MAP = {
+    "Zmieszane": Icons.GENERAL_WASTE,
+    "Tworzywa": Icons.RECYCLING,
+    "BIO": Icons.ORGANIC,
+    "Papier": Icons.PAPER,
+    "Szkło": Icons.GLASS,
+    "Gabaryty": Icons.BULKY,
+}
+
+
+class Source:
+    def __init__(self, street, city, nr):
+        self._city = city
+        self._street = street
+        self._nr = nr
+
+    def fetch(self):
+        address = API_URL.format(city=self._city, street=self._street, nr=self._nr)
+        response = req.get(address)
+
+        if response.status_code != 200:
+            print(f"Error fetching data from {address}: {response.status_code}")
+            return []
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        entries = []
+
+        waste_types = {
+            "plan rest clear": "Zmieszane",
+            "glas": "Szkło",
+            "plastik": "Tworzywa",
+            "bio": "BIO",
+            "papier": "Papier",
+            "plan sperr clear": "Gabaryty",
+        }
+
+        for waste_class, waste_type in waste_types.items():
+            try:
+                for li in soup.find(class_=waste_class).find_all("li"):
+                    date_text = li.text.strip()
+                    date_format = "%d.%m.%Y"
+                    cleaned_date_text = (
+                        date_text.replace("\r", "")
+                        .replace("\n", "")
+                        .replace("pon.,", "")
+                        .replace("wt.,", "")
+                        .replace("sr.,", "")
+                        .replace("śr.,", "")
+                        .replace("czw.,", "")
+                        .replace("pt.,", "")
+                        .replace("sob.,", "")
+                        .replace("nie.,", "")
+                        .strip()
+                    )
+                    date_str = str(
+                        datetime.datetime.strptime(
+                            cleaned_date_text, date_format
+                        ).date()
+                    )
+
+                    try:
+                        entries.append(
+                            Collection(
+                                date=datetime.datetime.strptime(
+                                    date_str, "%Y-%m-%d"
+                                ).date(),
+                                t=waste_type,
+                                icon=ICON_MAP.get(waste_type),
+                            )
+                        )
+
+                    except ValueError:
+                        _LOOGGER.debug(f"Error converting date string: {date_text}")
+
+            except AttributeError:
+                _LOOGGER.debug(f"No data found for waste type: {waste_type}")
+
+        return entries